dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422 #include <time.h>
 423
 424 #include <dali/dali.h>
 425 #include <dali-toolkit/dali-toolkit.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/common/stage-devel.h>
 429 #include <dali/devel-api/events/key-event-devel.h>
 430 #include <dali/devel-api/events/wheel-event-devel.h>
 431 #include <dali/devel-api/events/key-event-devel.h>
 432
 433 #include <dali/public-api/math/matrix.h>
 434 #include <dali/public-api/math/matrix3.h>
 435 #include <dali/public-api/math/viewport.h>
 436 #include <dali/public-api/object/property-key.h>
 437 #include <dali/devel-api/object/csharp-type-info.h>
 438 #include <dali/devel-api/object/csharp-type-registry.h>
 439
 440 #include <dali/public-api/adaptor-framework/timer.h>
 441 #include <dali/public-api/adaptor-framework/style-change.h>
 442 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 443
 444 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 460 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 461 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 462
 463 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 464 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 465 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 466
 467 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 469 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 470
 471 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 472 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 473 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 474
 475 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 476
 477 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 478 #include <dali/devel-api/adaptor-framework/image-loading.h>
 479
 480 #include <dali/public-api/events/mouse-button.h>
 481
 482 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 483 #include "web-view-signal-converter.h"
 484
 485 #include <dali/integration-api/debug.h>
 486
 487 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 488
 489 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 490
 491 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 492
 493
 494 #include <dali/devel-api/update/frame-callback-interface.h>
 495 #include <dali/devel-api/update/update-proxy.h>
 496
 497
 498 // add here SWIG version check
 499
 500 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 501 // disable Swig-dependent warnings
 502
 503 // 'identifier1' has C-linkage specified,
 504 // but returns UDT 'identifier2' which is incompatible with C
 505 #pragma warning(disable: 4190)
 506
 507 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 508 #pragma warning(disable: 4800)
 509
 510 // debug info too long etc etc
 511 #pragma warning(disable: 4786)
 512 #endif
 513
 514
 515 #include <stdexcept>
 516
 517
 518 #include <string>
 519
 520
 521 #include <vector>
 522 #include <algorithm>
 523 #include <stdexcept>
 524
 525
 526 #include <map>
 527 #include <algorithm>
 528 #include <stdexcept>
 529
 530
 531 #include <utility>
 532
 533
 534 typedef float floatp;
 535
 536 SWIGINTERN floatp *new_floatp(){
 537   return new float();
 538 }
 539 SWIGINTERN void delete_floatp(floatp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void floatp_assign(floatp *self,float value){
 543   *self = value;
 544 }
 545 SWIGINTERN float floatp_value(floatp *self){
 546   return *self;
 547 }
 548 SWIGINTERN float *floatp_cast(floatp *self){
 549   return self;
 550 }
 551 SWIGINTERN floatp *floatp_frompointer(float *t){
 552   return (floatp *) t;
 553 }
 554
 555 typedef int intp;
 556
 557 SWIGINTERN intp *new_intp(){
 558   return new int();
 559 }
 560 SWIGINTERN void delete_intp(intp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void intp_assign(intp *self,int value){
 564   *self = value;
 565 }
 566 SWIGINTERN int intp_value(intp *self){
 567   return *self;
 568 }
 569 SWIGINTERN int *intp_cast(intp *self){
 570   return self;
 571 }
 572 SWIGINTERN intp *intp_frompointer(int *t){
 573   return (intp *) t;
 574 }
 575
 576 typedef double doublep;
 577
 578 SWIGINTERN doublep *new_doublep(){
 579   return new double();
 580 }
 581 SWIGINTERN void delete_doublep(doublep *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void doublep_assign(doublep *self,double value){
 585   *self = value;
 586 }
 587 SWIGINTERN double doublep_value(doublep *self){
 588   return *self;
 589 }
 590 SWIGINTERN double *doublep_cast(doublep *self){
 591   return self;
 592 }
 593 SWIGINTERN doublep *doublep_frompointer(double *t){
 594   return (doublep *) t;
 595 }
 596
 597 typedef unsigned int uintp;
 598
 599 SWIGINTERN uintp *new_uintp(){
 600   return new unsigned int();
 601 }
 602 SWIGINTERN void delete_uintp(uintp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned int uintp_value(uintp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 612   return self;
 613 }
 614 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 615   return (uintp *) t;
 616 }
 617
 618 typedef unsigned short ushortp;
 619
 620 SWIGINTERN ushortp *new_ushortp(){
 621   return new unsigned short();
 622 }
 623 SWIGINTERN void delete_ushortp(ushortp *self){
 624   if (self) delete self;
 625 }
 626 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 627   *self = value;
 628 }
 629 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 630   return *self;
 631 }
 632 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 633   return self;
 634 }
 635 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 636   return (ushortp *) t;
 637 }
 638
 639 unsigned int int_to_uint(int x) {
 640    return (unsigned int) x;
 641 }
 642
 643
 644 using namespace Dali;
 645 using namespace Dali::Toolkit;
 646
 647 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 648 {
 649   bool result = false;
 650   try
 651   {
 652     // C++ code. DALi uses Handle <-> Body design pattern.
 653     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 654     // Handles in DALi can be converted into a boolean type
 655     // to check if the handle has a valid body attached to it.
 656     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 657     if( *self )
 658     {
 659       result = true;
 660     }
 661     else
 662     {
 663       result = false;
 664     }
 665   }
 666   catch (std::out_of_range& e)
 667   {
 668     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 669     return 0;
 670   }
 671   catch (std::exception& e)
 672   {
 673     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 674     return 0;
 675   }
 676   catch (DaliException e)
 677   {
 678     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 679     return 0;
 680   }
 681   catch (...)
 682   {
 683     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 684     return 0;
 685   }
 686   return result;
 687 }
 688
 689 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 690 {
 691   bool result = false;
 692   try
 693   {
 694     // C++ code. Check if two handles reference the same implemtion
 695     if( *self == rhs)
 696     {
 697       result = true;
 698     }
 699     else
 700     {
 701       result = false;
 702     }
 703   }
 704   catch (std::out_of_range& e)
 705   {
 706     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 707     return 0;
 708   }
 709   catch (std::exception& e)
 710   {
 711     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 712     return 0;
 713   }
 714   catch (DaliException e)
 715   {
 716     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 717     return 0;
 718   }
 719   catch (...)
 720   {
 721     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 722     return 0;
 723   }
 724   return result;
 725 }
 726
 727
 728 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 729      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 730    }
 731 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){
 732      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 733    }
 734 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 735         std::vector< Dali::TouchPoint >* pv = 0;
 736         if (capacity >= 0) {
 737           pv = new std::vector< Dali::TouchPoint >();
 738           pv->reserve(capacity);
 739        } else {
 740           throw std::out_of_range("capacity");
 741        }
 742        return pv;
 743       }
 744 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 745         if (index>=0 && index<(int)self->size())
 746           return (*self)[index];
 747         else
 748           throw std::out_of_range("index");
 749       }
 750 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 751         if (index>=0 && index<(int)self->size())
 752           return (*self)[index];
 753         else
 754           throw std::out_of_range("index");
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 757         if (index>=0 && index<(int)self->size())
 758           (*self)[index] = val;
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 763         self->insert(self->end(), values.begin(), values.end());
 764       }
 765 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 766         if (index < 0)
 767           throw std::out_of_range("index");
 768         if (count < 0)
 769           throw std::out_of_range("count");
 770         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 771           throw std::invalid_argument("invalid range");
 772         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 773       }
 774 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 775         if (index>=0 && index<(int)self->size()+1)
 776           self->insert(self->begin()+index, x);
 777         else
 778           throw std::out_of_range("index");
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 781         if (index>=0 && index<(int)self->size()+1)
 782           self->insert(self->begin()+index, values.begin(), values.end());
 783         else
 784           throw std::out_of_range("index");
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 787         if (index>=0 && index<(int)self->size())
 788           self->erase(self->begin() + index);
 789         else
 790           throw std::out_of_range("index");
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         self->erase(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 802         if (count < 0)
 803           throw std::out_of_range("count");
 804         return new std::vector< Dali::TouchPoint >(count, value);
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 807         std::reverse(self->begin(), self->end());
 808       }
 809 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 810         if (index < 0)
 811           throw std::out_of_range("index");
 812         if (count < 0)
 813           throw std::out_of_range("count");
 814         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 815           throw std::invalid_argument("invalid range");
 816         std::reverse(self->begin()+index, self->begin()+index+count);
 817       }
 818 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 819         if (index < 0)
 820           throw std::out_of_range("index");
 821         if (index+values.size() > self->size())
 822           throw std::out_of_range("index");
 823         std::copy(values.begin(), values.end(), self->begin()+index);
 824       }
 825 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 826          return self->Empty();
 827       }
 828 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 829         return self->GetConnectionCount();
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 832           self->Connect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 835           self->Disconnect( func );
 836       }
 837 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 838           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 839 /*@SWIG@*/ self->Emit( arg );
 840       }
 841 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 842          return self->Empty();
 843       }
 844 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 845         return self->GetConnectionCount();
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 848           self->Connect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 851           self->Disconnect( func );
 852       }
 853 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 854           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 855 /*@SWIG@*/ self->Emit( arg );
 856       }
 857 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 858          return self->Empty();
 859       }
 860 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){
 861         return self->GetConnectionCount();
 862       }
 863 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 *)){
 864           self->Connect( func );
 865       }
 866 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 *)){
 867           self->Disconnect( func );
 868       }
 869 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){
 870           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 871 /*@SWIG@*/ self->Emit( arg );
 872       }
 873 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 874          return self->Empty();
 875       }
 876 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 877         return self->GetConnectionCount();
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 880           self->Connect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 883           self->Disconnect( func );
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 886           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 887 /*@SWIG@*/ self->Emit( arg );
 888       }
 889 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){
 890          return self->Empty();
 891       }
 892 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){
 893         return self->GetConnectionCount();
 894       }
 895 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 &)){
 896         self->Connect( func );
 897       }
 898 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 &)){
 899         self->Disconnect( func );
 900       }
 901 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){
 902         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 903 /*@SWIG@*/ self->Emit( arg1, arg2 );
 904       }
 905 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){
 906          return self->Empty();
 907       }
 908 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){
 909         return self->GetConnectionCount();
 910       }
 911 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 &)){
 912         self->Connect( func );
 913       }
 914 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 &)){
 915         self->Disconnect( func );
 916       }
 917 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){
 918         return self->Emit( arg1, arg2 );
 919       }
 920 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){
 921          return self->Empty();
 922       }
 923 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){
 924         return self->GetConnectionCount();
 925       }
 926 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 &)){
 927         self->Connect( func );
 928       }
 929 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 &)){
 930         self->Disconnect( func );
 931       }
 932 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){
 933         return self->Emit( arg1, arg2 );
 934       }
 935 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){
 936          return self->Empty();
 937       }
 938 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){
 939         return self->GetConnectionCount();
 940       }
 941 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 &)){
 942         self->Connect( func );
 943       }
 944 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 &)){
 945         self->Disconnect( func );
 946       }
 947 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){
 948         return self->Emit( arg1, arg2 );
 949       }
 950 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 951          return self->Empty();
 952       }
 953 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 954         return self->GetConnectionCount();
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Connect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 960           self->Disconnect( func );
 961       }
 962 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 963           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 964 /*@SWIG@*/ self->Emit( arg );
 965       }
 966 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 967          return self->Empty();
 968       }
 969 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){
 970         return self->GetConnectionCount();
 971       }
 972 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 &)){
 973           self->Connect( func );
 974       }
 975 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 &)){
 976           self->Disconnect( func );
 977       }
 978 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){
 979           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 980 /*@SWIG@*/ self->Emit( arg );
 981       }
 982 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 983          return self->Empty();
 984       }
 985 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){
 986         return self->GetConnectionCount();
 987       }
 988 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 &)){
 989           self->Connect( func );
 990       }
 991 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 &)){
 992           self->Disconnect( func );
 993       }
 994 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){
 995           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 996 /*@SWIG@*/ self->Emit( arg );
 997       }
 998 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 999          return self->Empty();
1000       }
1001 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){
1002         return self->GetConnectionCount();
1003       }
1004 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 &)){
1005           self->Connect( func );
1006       }
1007 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 &)){
1008           self->Disconnect( func );
1009       }
1010 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){
1011           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1012 /*@SWIG@*/ self->Emit( arg );
1013       }
1014 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){
1015          return self->Empty();
1016       }
1017 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){
1018         return self->GetConnectionCount();
1019       }
1020 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 &)){
1021         self->Connect( func );
1022       }
1023 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 &)){
1024         self->Disconnect( func );
1025       }
1026 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){
1027         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1028 /*@SWIG@*/ self->Emit( arg1, arg2 );
1029       }
1030 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){
1031          return self->Empty();
1032       }
1033 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){
1034         return self->GetConnectionCount();
1035       }
1036 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 &)){
1037         self->Connect( func );
1038       }
1039 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 &)){
1040         self->Disconnect( func );
1041       }
1042 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){
1043         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1044 /*@SWIG@*/ self->Emit( arg1, arg2 );
1045       }
1046 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){
1047          return self->Empty();
1048       }
1049 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){
1050         return self->GetConnectionCount();
1051       }
1052 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 &)){
1053         self->Connect( func );
1054       }
1055 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 &)){
1056         self->Disconnect( func );
1057       }
1058 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){
1059         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1060 /*@SWIG@*/ self->Emit( arg1, arg2 );
1061       }
1062 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){
1063          return self->Empty();
1064       }
1065 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){
1066         return self->GetConnectionCount();
1067       }
1068 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)){
1069           return self->Connect( func );
1070       }
1071 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)){
1072           self->Disconnect( func );
1073       }
1074 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){
1075           self->Emit( arg1, arg3 );
1076       }
1077 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){
1078          return self->Empty();
1079       }
1080 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){
1081         return self->GetConnectionCount();
1082       }
1083 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)){
1084           return self->Connect( func );
1085       }
1086 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)){
1087           self->Disconnect( func );
1088       }
1089 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){
1090           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1091 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1092       }
1093
1094 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1095          return self->Empty();
1096       }
1097 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1098         return self->GetConnectionCount();
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Connect( func );
1102       }
1103 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1104           self->Disconnect( func );
1105       }
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1107           return self->Emit();
1108       }
1109
1110 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1111         std::vector< unsigned int >* pv = 0;
1112         if (capacity >= 0) {
1113           pv = new std::vector< unsigned int >();
1114           pv->reserve(capacity);
1115        } else {
1116           throw std::out_of_range("capacity");
1117        }
1118        return pv;
1119       }
1120 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1121         if (index>=0 && index<(int)self->size())
1122           return (*self)[index];
1123         else
1124           throw std::out_of_range("index");
1125       }
1126 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1133         if (index>=0 && index<(int)self->size())
1134           (*self)[index] = val;
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1139         self->insert(self->end(), values.begin(), values.end());
1140       }
1141 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1142         if (index < 0)
1143           throw std::out_of_range("index");
1144         if (count < 0)
1145           throw std::out_of_range("count");
1146         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1147           throw std::invalid_argument("invalid range");
1148         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1151         if (index>=0 && index<(int)self->size()+1)
1152           self->insert(self->begin()+index, x);
1153         else
1154           throw std::out_of_range("index");
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, values.begin(), values.end());
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1163         if (index>=0 && index<(int)self->size())
1164           self->erase(self->begin() + index);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1169         if (index < 0)
1170           throw std::out_of_range("index");
1171         if (count < 0)
1172           throw std::out_of_range("count");
1173         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1174           throw std::invalid_argument("invalid range");
1175         self->erase(self->begin()+index, self->begin()+index+count);
1176       }
1177 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1178         if (count < 0)
1179           throw std::out_of_range("count");
1180         return new std::vector< unsigned int >(count, value);
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1183         std::reverse(self->begin(), self->end());
1184       }
1185 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1186         if (index < 0)
1187           throw std::out_of_range("index");
1188         if (count < 0)
1189           throw std::out_of_range("count");
1190         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1191           throw std::invalid_argument("invalid range");
1192         std::reverse(self->begin()+index, self->begin()+index+count);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (index+values.size() > self->size())
1198           throw std::out_of_range("index");
1199         std::copy(values.begin(), values.end(), self->begin()+index);
1200       }
1201 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1202         return std::find(self->begin(), self->end(), value) != self->end();
1203       }
1204 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1205         int index = -1;
1206         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1207         if (it != self->end())
1208           index = (int)(it - self->begin());
1209         return index;
1210       }
1211 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1212         int index = -1;
1213         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1214         if (rit != self->rend())
1215           index = (int)(self->rend() - 1 - rit);
1216         return index;
1217       }
1218 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end()) {
1221           self->erase(it);
1222           return true;
1223         }
1224         return false;
1225       }
1226 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){
1227         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1228         if (capacity >= 0) {
1229           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1230           pv->reserve(capacity);
1231        } else {
1232           throw std::out_of_range("capacity");
1233        }
1234        return pv;
1235       }
1236 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){
1237         if (index>=0 && index<(int)self->size())
1238           return (*self)[index];
1239         else
1240           throw std::out_of_range("index");
1241       }
1242 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){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           (*self)[index] = val;
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         self->insert(self->end(), values.begin(), values.end());
1256       }
1257 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){
1258         if (index < 0)
1259           throw std::out_of_range("index");
1260         if (count < 0)
1261           throw std::out_of_range("count");
1262         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1263           throw std::invalid_argument("invalid range");
1264         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1265       }
1266 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){
1267         if (index>=0 && index<(int)self->size()+1)
1268           self->insert(self->begin()+index, x);
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 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){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, values.begin(), values.end());
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size())
1280           self->erase(self->begin() + index);
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index < 0)
1286           throw std::out_of_range("index");
1287         if (count < 0)
1288           throw std::out_of_range("count");
1289         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1290           throw std::invalid_argument("invalid range");
1291         self->erase(self->begin()+index, self->begin()+index+count);
1292       }
1293 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){
1294         if (count < 0)
1295           throw std::out_of_range("count");
1296         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1297       }
1298 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){
1299         std::reverse(self->begin(), self->end());
1300       }
1301 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){
1302         if (index < 0)
1303           throw std::out_of_range("index");
1304         if (count < 0)
1305           throw std::out_of_range("count");
1306         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1307           throw std::invalid_argument("invalid range");
1308         std::reverse(self->begin()+index, self->begin()+index+count);
1309       }
1310 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){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (index+values.size() > self->size())
1314           throw std::out_of_range("index");
1315         std::copy(values.begin(), values.end(), self->begin()+index);
1316       }
1317 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1318         std::vector< Dali::Actor >* pv = 0;
1319         if (capacity >= 0) {
1320           pv = new std::vector< Dali::Actor >();
1321           pv->reserve(capacity);
1322        } else {
1323           throw std::out_of_range("capacity");
1324        }
1325        return pv;
1326       }
1327 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1328         if (index>=0 && index<(int)self->size())
1329           return (*self)[index];
1330         else
1331           throw std::out_of_range("index");
1332       }
1333 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1340         if (index>=0 && index<(int)self->size())
1341           (*self)[index] = val;
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1346         self->insert(self->end(), values.begin(), values.end());
1347       }
1348 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1349         if (index < 0)
1350           throw std::out_of_range("index");
1351         if (count < 0)
1352           throw std::out_of_range("count");
1353         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1354           throw std::invalid_argument("invalid range");
1355         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1358         if (index>=0 && index<(int)self->size()+1)
1359           self->insert(self->begin()+index, x);
1360         else
1361           throw std::out_of_range("index");
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, values.begin(), values.end());
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1370         if (index>=0 && index<(int)self->size())
1371           self->erase(self->begin() + index);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1376         if (index < 0)
1377           throw std::out_of_range("index");
1378         if (count < 0)
1379           throw std::out_of_range("count");
1380         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1381           throw std::invalid_argument("invalid range");
1382         self->erase(self->begin()+index, self->begin()+index+count);
1383       }
1384 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1385         if (count < 0)
1386           throw std::out_of_range("count");
1387         return new std::vector< Dali::Actor >(count, value);
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1390         std::reverse(self->begin(), self->end());
1391       }
1392 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1393         if (index < 0)
1394           throw std::out_of_range("index");
1395         if (count < 0)
1396           throw std::out_of_range("count");
1397         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1398           throw std::invalid_argument("invalid range");
1399         std::reverse(self->begin()+index, self->begin()+index+count);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (index+values.size() > self->size())
1405           throw std::out_of_range("index");
1406         std::copy(values.begin(), values.end(), self->begin()+index);
1407       }
1408 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409          return self->Empty();
1410       }
1411 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1412         return self->GetConnectionCount();
1413       }
1414 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 &)){
1415           self->Connect( func );
1416       }
1417 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 &)){
1418           self->Disconnect( func );
1419       }
1420 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){
1421           return self->Emit( arg );
1422       }
1423 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){
1424          return self->Empty();
1425       }
1426 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){
1427         return self->GetConnectionCount();
1428       }
1429 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)){
1430         self->Connect( func );
1431       }
1432 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)){
1433         self->Disconnect( func );
1434       }
1435 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){
1436         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1437 /*@SWIG@*/ self->Emit( arg1, arg2 );
1438       }
1439 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1440          return self->Empty();
1441       }
1442 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){
1443         return self->GetConnectionCount();
1444       }
1445 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)){
1446         self->Connect( func );
1447       }
1448 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)){
1449         self->Disconnect( func );
1450       }
1451 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){
1452         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1453 /*@SWIG@*/ self->Emit( arg1, arg2 );
1454       }
1455 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456          return self->Empty();
1457       }
1458 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1459         return self->GetConnectionCount();
1460       }
1461 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)){
1462         self->Connect( func );
1463       }
1464 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)){
1465         self->Disconnect( func );
1466       }
1467 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){
1468         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1469 /*@SWIG@*/ self->Emit( arg1, arg2 );
1470       }
1471 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){
1472          return self->Empty();
1473       }
1474 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){
1475         return self->GetConnectionCount();
1476       }
1477 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)){
1478         self->Connect( func );
1479       }
1480 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)){
1481         self->Disconnect( func );
1482       }
1483 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){
1484         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1485 /*@SWIG@*/ self->Emit( arg1, arg2 );
1486       }
1487 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488          return self->Empty();
1489       }
1490 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1491         return self->GetConnectionCount();
1492       }
1493 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)){
1494           self->Connect( func );
1495       }
1496 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)){
1497           self->Disconnect( func );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1500           return self->Emit( arg );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 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)){
1509           self->Connect( func );
1510       }
1511 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)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1515           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1516 /*@SWIG@*/ self->Emit( arg );
1517       }
1518 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){
1519          return self->Empty();
1520       }
1521 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){
1522         return self->GetConnectionCount();
1523       }
1524 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)){
1525           return self->Connect( func );
1526       }
1527 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)){
1528           self->Disconnect( func );
1529       }
1530 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){
1531           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1532 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1533       }
1534 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535          return self->Empty();
1536       }
1537 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1538         return self->GetConnectionCount();
1539       }
1540 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)){
1541           self->Connect( func );
1542       }
1543 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)){
1544           self->Disconnect( func );
1545       }
1546 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1547           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1548 /*@SWIG@*/ self->Emit( arg );
1549       }
1550 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){
1551          return self->Empty();
1552       }
1553 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){
1554         return self->GetConnectionCount();
1555       }
1556 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)){
1557           return self->Connect( func );
1558       }
1559 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)){
1560           self->Disconnect( func );
1561       }
1562 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){
1563           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1564 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1565       }
1566 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){
1567          return self->Empty();
1568       }
1569 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){
1570         return self->GetConnectionCount();
1571       }
1572 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 &)){
1573           self->Connect( func );
1574       }
1575 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 &)){
1576           self->Disconnect( func );
1577       }
1578 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){
1579           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1580 /*@SWIG@*/ self->Emit( arg );
1581       }
1582 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1583          return self->Empty();
1584       }
1585 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){
1586         return self->GetConnectionCount();
1587       }
1588 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 &)){
1589           self->Connect( func );
1590       }
1591 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 &)){
1592           self->Disconnect( func );
1593       }
1594 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){
1595           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1596 /*@SWIG@*/ self->Emit( arg );
1597       }
1598
1599
1600 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){
1601          return self->Empty();
1602       }
1603 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){
1604         return self->GetConnectionCount();
1605       }
1606 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 &)){
1607         self->Connect( func );
1608       }
1609 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 &)){
1610         self->Disconnect( func );
1611       }
1612 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){
1613         return self->Emit( arg1, arg2 );
1614       }
1615 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616          return self->Empty();
1617       }
1618 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1619         return self->GetConnectionCount();
1620       }
1621 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)){
1622           self->Connect( func );
1623       }
1624 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)){
1625           self->Disconnect( func );
1626       }
1627 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1628           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1629 /*@SWIG@*/ self->Emit( arg );
1630       }
1631 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632          return self->Empty();
1633       }
1634 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1635         return self->GetConnectionCount();
1636       }
1637 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 &)){
1638           self->Connect( func );
1639       }
1640 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 &)){
1641           self->Disconnect( func );
1642       }
1643 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){
1644           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1645 /*@SWIG@*/ self->Emit( arg );
1646       }
1647 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1648          return self->Empty();
1649       }
1650 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){
1651         return self->GetConnectionCount();
1652       }
1653 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)){
1654         self->Connect( func );
1655       }
1656 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)){
1657         self->Disconnect( func );
1658       }
1659 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){
1660         return self->Emit( arg1, arg2 );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1663          return self->Empty();
1664       }
1665 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){
1666         return self->GetConnectionCount();
1667       }
1668 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)){
1669         self->Connect( func );
1670       }
1671 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)){
1672         self->Disconnect( func );
1673       }
1674 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){
1675         return self->Emit( arg1, arg2 );
1676       }
1677
1678 /* ---------------------------------------------------
1679  * C++ director class methods
1680  * --------------------------------------------------- */
1681
1682 #include "dali_wrap.h"
1683
1684 /*
1685  *  Widget director
1686  */
1687 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1688   swig_init_callbacks();
1689 }
1690
1691 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1692 }
1693
1694 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1695   char * jcontentInfo = 0 ;
1696   void * jwindow  ;
1697
1698   if (!swig_callbackOnCreate) {
1699     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1700     return;
1701   } else {
1702     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1703     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1704     swig_callbackOnCreate(jcontentInfo, jwindow);
1705   }
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1709   char * jcontentInfo = 0 ;
1710   int jtype  ;
1711
1712   if (!swig_callbackOnTerminate) {
1713     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1714     return;
1715   } else {
1716     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1717     jtype = (int)type;
1718     swig_callbackOnTerminate(jcontentInfo, jtype);
1719   }
1720 }
1721
1722 void SwigDirector_WidgetImpl::OnPause() {
1723   if (!swig_callbackOnPause) {
1724     Dali::Internal::Adaptor::Widget::OnPause();
1725     return;
1726   } else {
1727     swig_callbackOnPause();
1728   }
1729 }
1730
1731 void SwigDirector_WidgetImpl::OnResume() {
1732   if (!swig_callbackOnResume) {
1733     Dali::Internal::Adaptor::Widget::OnResume();
1734     return;
1735   } else {
1736     swig_callbackOnResume();
1737   }
1738 }
1739
1740 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1741   void * jwindow  ;
1742
1743   if (!swig_callbackOnResize) {
1744     Dali::Internal::Adaptor::Widget::OnResize(window);
1745     return;
1746   } else {
1747     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1748     swig_callbackOnResize(jwindow);
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1753   char * jcontentInfo = 0 ;
1754   int jforce  ;
1755
1756   if (!swig_callbackOnUpdate) {
1757     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1758     return;
1759   } else {
1760     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1761     jforce = force;
1762     swig_callbackOnUpdate(jcontentInfo, jforce);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1767   void * jslotObserver = 0 ;
1768   void * jcallback = 0 ;
1769
1770   if (!swig_callbackSignalConnected) {
1771     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1772     return;
1773   } else {
1774     jslotObserver = (void *) slotObserver;
1775     jcallback = (void *) callback;
1776     swig_callbackSignalConnected(jslotObserver, jcallback);
1777   }
1778 }
1779
1780 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1781   void * jslotObserver = 0 ;
1782   void * jcallback = 0 ;
1783
1784   if (!swig_callbackSignalDisconnected) {
1785     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1786     return;
1787   } else {
1788     jslotObserver = (void *) slotObserver;
1789     jcallback = (void *) callback;
1790     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1791   }
1792 }
1793
1794 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) {
1795
1796   swig_callbackOnCreate = callbackOnCreate;
1797   swig_callbackOnTerminate = callbackOnTerminate;
1798   swig_callbackOnPause = callbackOnPause;
1799   swig_callbackOnResume = callbackOnResume;
1800   swig_callbackOnResize = callbackOnResize;
1801   swig_callbackOnUpdate = callbackOnUpdate;
1802   swig_callbackSignalConnected = callbackSignalConnected;
1803   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1804 }
1805
1806 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1807   swig_callbackOnCreate = 0;
1808   swig_callbackOnTerminate = 0;
1809   swig_callbackOnPause = 0;
1810   swig_callbackOnResume = 0;
1811   swig_callbackOnResize = 0;
1812   swig_callbackOnUpdate = 0;
1813   swig_callbackSignalConnected = 0;
1814   swig_callbackSignalDisconnected = 0;
1815 }
1816
1817
1818 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1819   swig_init_callbacks();
1820 }
1821
1822 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1823
1824 }
1825
1826
1827 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1828   int jdepth  ;
1829
1830   if (!swig_callbackOnSceneConnection) {
1831     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1832     return;
1833   } else {
1834     jdepth = depth;
1835     swig_callbackOnSceneConnection(jdepth);
1836   }
1837 }
1838
1839 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1840   if (!swig_callbackOnSceneDisconnection) {
1841     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1842     return;
1843   } else {
1844     swig_callbackOnSceneDisconnection();
1845   }
1846 }
1847
1848 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1849   void * jchild = 0 ;
1850
1851   if (!swig_callbackOnChildAdd) {
1852     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1853     return;
1854   } else {
1855     jchild = (Dali::Actor *) &child;
1856     swig_callbackOnChildAdd(jchild);
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildRemove) {
1864     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildRemove(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1873   int jindex  ;
1874   void * jpropertyValue  ;
1875
1876   if (!swig_callbackOnPropertySet) {
1877     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1878     return;
1879   } else {
1880     jindex = index;
1881     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1882     swig_callbackOnPropertySet(jindex, jpropertyValue);
1883   }
1884 }
1885
1886 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1887   void * jtargetSize = 0 ;
1888
1889   if (!swig_callbackOnSizeSet) {
1890     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1891     return;
1892   } else {
1893     jtargetSize = (Dali::Vector3 *) &targetSize;
1894     swig_callbackOnSizeSet(jtargetSize);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1899   void * janimation = 0 ;
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeAnimation) {
1903     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1904     return;
1905   } else {
1906     janimation = (Dali::Animation *) &animation;
1907     jtargetSize = (Dali::Vector3 *) &targetSize;
1908     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1909   }
1910 }
1911
1912 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1913   bool c_result = SwigValueInit< bool >() ;
1914   unsigned int jresult = 0 ;
1915   void * jarg0 = 0 ;
1916
1917   if (!swig_callbackOnHoverEvent) {
1918     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1919   } else {
1920     jarg0 = (Dali::HoverEvent *) &event;
1921     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1922     c_result = jresult ? true : false;
1923   }
1924   return c_result;
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnKeyEvent) {
1933     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1934   } else {
1935     jarg0 = (Dali::KeyEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnWheelEvent) {
1948     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1949   } else {
1950     jarg0 = (Dali::WheelEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1958   void * jsize = 0 ;
1959   void * jcontainer = 0 ;
1960
1961   if (!swig_callbackOnRelayout) {
1962     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1963     return;
1964   } else {
1965     jsize = (Dali::Vector2 *) &size;
1966     jcontainer = (Dali::RelayoutContainer *) &container;
1967     swig_callbackOnRelayout(jsize, jcontainer);
1968   }
1969 }
1970
1971 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1972   int jpolicy  ;
1973   int jdimension  ;
1974
1975   if (!swig_callbackOnSetResizePolicy) {
1976     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1977     return;
1978   } else {
1979     jpolicy = (int)policy;
1980     jdimension = (int)dimension;
1981     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1982   }
1983 }
1984
1985 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1986   Dali::Vector3 c_result ;
1987   void * jresult = 0 ;
1988
1989   if (!swig_callbackGetNaturalSize) {
1990     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1991   } else {
1992     jresult = (void *) swig_callbackGetNaturalSize();
1993     if (!jresult) {
1994       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1995       return c_result;
1996     }
1997     c_result = *(Dali::Vector3 *)jresult;
1998   }
1999   return c_result;
2000 }
2001
2002 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2003   float c_result = SwigValueInit< float >() ;
2004   float jresult = 0 ;
2005   void * jchild = 0 ;
2006   int jdimension  ;
2007
2008   if (!swig_callbackCalculateChildSize) {
2009     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2010   } else {
2011     jchild = (Dali::Actor *) &child;
2012     jdimension = (int)dimension;
2013     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2014     c_result = (float)jresult;
2015   }
2016   return c_result;
2017 }
2018
2019 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2020   float c_result = SwigValueInit< float >() ;
2021   float jresult = 0 ;
2022   float jwidth  ;
2023
2024   if (!swig_callbackGetHeightForWidth) {
2025     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2026   } else {
2027     jwidth = width;
2028     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2029     c_result = (float)jresult;
2030   }
2031   return c_result;
2032 }
2033
2034 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2035   float c_result = SwigValueInit< float >() ;
2036   float jresult = 0 ;
2037   float jheight  ;
2038
2039   if (!swig_callbackGetWidthForHeight) {
2040     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2041   } else {
2042     jheight = height;
2043     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2050   bool c_result = SwigValueInit< bool >() ;
2051   unsigned int jresult = 0 ;
2052   int jdimension  ;
2053
2054   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2055     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2056   } else {
2057     jdimension = (int)dimension;
2058     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2059     c_result = jresult ? true : false;
2060   }
2061   return c_result;
2062 }
2063
2064 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2065   int jdimension  ;
2066
2067   if (!swig_callbackOnCalculateRelayoutSize) {
2068     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2069     return;
2070   } else {
2071     jdimension = (int)dimension;
2072     swig_callbackOnCalculateRelayoutSize(jdimension);
2073   }
2074 }
2075
2076 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2077   float jsize  ;
2078   int jdimension  ;
2079
2080   if (!swig_callbackOnLayoutNegotiated) {
2081     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2082     return;
2083   } else {
2084     jsize = size;
2085     jdimension = (int)dimension;
2086     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2087   }
2088 }
2089
2090 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2091   return Dali::CustomActorImpl::GetExtension();
2092 }
2093
2094 void SwigDirector_ViewImpl::OnInitialize() {
2095   if (!swig_callbackOnInitialize) {
2096     Dali::Toolkit::Internal::Control::OnInitialize();
2097     return;
2098   } else {
2099     swig_callbackOnInitialize();
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2104   void * jstyleManager  ;
2105   int jchange  ;
2106
2107   if (!swig_callbackOnStyleChange) {
2108     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2109     return;
2110   } else {
2111     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2112     jchange = (int)change;
2113     swig_callbackOnStyleChange(jstyleManager, jchange);
2114   }
2115 }
2116
2117 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2118   bool c_result = SwigValueInit< bool >() ;
2119   unsigned int jresult = 0 ;
2120
2121   if (!swig_callbackOnAccessibilityActivated) {
2122     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2123   } else {
2124     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2125     c_result = jresult ? true : false;
2126   }
2127   return c_result;
2128 }
2129
2130 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2131   bool c_result = SwigValueInit< bool >() ;
2132   unsigned int jresult = 0 ;
2133   void * jgesture  ;
2134
2135   if (!swig_callbackOnAccessibilityPan) {
2136     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2137   } else {
2138     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2139     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2140     c_result = jresult ? true : false;
2141   }
2142   return c_result;
2143 }
2144
2145 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2146   bool c_result = SwigValueInit< bool >() ;
2147   unsigned int jresult = 0 ;
2148   unsigned int jisIncrease  ;
2149
2150   if (!swig_callbackOnAccessibilityValueChange) {
2151     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2152   } else {
2153     jisIncrease = isIncrease;
2154     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2155     c_result = jresult ? true : false;
2156   }
2157   return c_result;
2158 }
2159
2160 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2161   bool c_result = SwigValueInit< bool >() ;
2162   unsigned int jresult = 0 ;
2163
2164   if (!swig_callbackOnAccessibilityZoom) {
2165     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2166   } else {
2167     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2168     c_result = jresult ? true : false;
2169   }
2170   return c_result;
2171 }
2172
2173 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2174   if (!swig_callbackOnKeyInputFocusGained) {
2175     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2176     return;
2177   } else {
2178     swig_callbackOnKeyInputFocusGained();
2179   }
2180 }
2181
2182 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2183   if (!swig_callbackOnKeyInputFocusLost) {
2184     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2185     return;
2186   } else {
2187     swig_callbackOnKeyInputFocusLost();
2188   }
2189 }
2190
2191 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2192   Dali::Actor c_result ;
2193   void * jresult = 0 ;
2194   void * jcurrentFocusedActor  ;
2195   int jdirection  ;
2196   unsigned int jloopEnabled  ;
2197
2198   if (!swig_callbackGetNextKeyboardFocusableActor) {
2199     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2200   } else {
2201     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2202     jdirection = (int)direction;
2203     jloopEnabled = loopEnabled;
2204     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2205     if (!jresult) {
2206       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2207       return c_result;
2208     }
2209     c_result = *(Dali::Actor *)jresult;
2210   }
2211   return c_result;
2212 }
2213
2214 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2215   void * jcommitedFocusableActor  ;
2216
2217   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2218     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2219     return;
2220   } else {
2221     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2222     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2223   }
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnKeyboardEnter) {
2231     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2240   void * jpinch = 0 ;
2241
2242   if (!swig_callbackOnPinch) {
2243     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2244     return;
2245   } else {
2246     jpinch = (Dali::PinchGesture *) &pinch;
2247     swig_callbackOnPinch(jpinch);
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2252   void * jpan = 0 ;
2253
2254   if (!swig_callbackOnPan) {
2255     Dali::Toolkit::Internal::Control::OnPan(pan);
2256     return;
2257   } else {
2258     jpan = (Dali::PanGesture *) &pan;
2259     swig_callbackOnPan(jpan);
2260   }
2261 }
2262
2263 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2264   void * jtap = 0 ;
2265
2266   if (!swig_callbackOnTap) {
2267     Dali::Toolkit::Internal::Control::OnTap(tap);
2268     return;
2269   } else {
2270     jtap = (Dali::TapGesture *) &tap;
2271     swig_callbackOnTap(jtap);
2272   }
2273 }
2274
2275 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2276   void * jlongPress = 0 ;
2277
2278   if (!swig_callbackOnLongPress) {
2279     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2280     return;
2281   } else {
2282     jlongPress = (Dali::LongPressGesture *) &longPress;
2283     swig_callbackOnLongPress(jlongPress);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2288   void * jslotObserver = 0 ;
2289   void * jcallback = 0 ;
2290
2291   if (!swig_callbackSignalConnected) {
2292     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2293     return;
2294   } else {
2295     jslotObserver = (void *) slotObserver;
2296     jcallback = (void *) callback;
2297     swig_callbackSignalConnected(jslotObserver, jcallback);
2298   }
2299 }
2300
2301 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2302   void * jslotObserver = 0 ;
2303   void * jcallback = 0 ;
2304
2305   if (!swig_callbackSignalDisconnected) {
2306     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2307     return;
2308   } else {
2309     jslotObserver = (void *) slotObserver;
2310     jcallback = (void *) callback;
2311     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2312   }
2313 }
2314
2315 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2316   return Dali::Toolkit::Internal::Control::GetControlExtension();
2317 }
2318
2319 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) {
2320   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2321   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2322   swig_callbackOnChildAdd = callbackOnChildAdd;
2323   swig_callbackOnChildRemove = callbackOnChildRemove;
2324   swig_callbackOnPropertySet = callbackOnPropertySet;
2325   swig_callbackOnSizeSet = callbackOnSizeSet;
2326   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2327   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2328   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2329   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2330   swig_callbackOnRelayout = callbackOnRelayout;
2331   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2332   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2333   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2334   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2335   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2336   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2337   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2338   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2339   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2340   swig_callbackOnInitialize = callbackOnInitialize;
2341   swig_callbackOnStyleChange = callbackOnStyleChange;
2342   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2343   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2344   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2345   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2346   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2347   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2348   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2349   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2350   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2351   swig_callbackOnPinch = callbackOnPinch;
2352   swig_callbackOnPan = callbackOnPan;
2353   swig_callbackOnTap = callbackOnTap;
2354   swig_callbackOnLongPress = callbackOnLongPress;
2355   swig_callbackSignalConnected = callbackSignalConnected;
2356   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2357 }
2358
2359 void SwigDirector_ViewImpl::swig_init_callbacks() {
2360   swig_callbackOnSceneConnection = 0;
2361   swig_callbackOnSceneDisconnection = 0;
2362   swig_callbackOnChildAdd = 0;
2363   swig_callbackOnChildRemove = 0;
2364   swig_callbackOnPropertySet = 0;
2365   swig_callbackOnSizeSet = 0;
2366   swig_callbackOnSizeAnimation = 0;
2367   swig_callbackOnHoverEvent = 0;
2368   swig_callbackOnKeyEvent = 0;
2369   swig_callbackOnWheelEvent = 0;
2370   swig_callbackOnRelayout = 0;
2371   swig_callbackOnSetResizePolicy = 0;
2372   swig_callbackGetNaturalSize = 0;
2373   swig_callbackCalculateChildSize = 0;
2374   swig_callbackGetHeightForWidth = 0;
2375   swig_callbackGetWidthForHeight = 0;
2376   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2377   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2378   swig_callbackOnCalculateRelayoutSize = 0;
2379   swig_callbackOnLayoutNegotiated = 0;
2380   swig_callbackOnInitialize = 0;
2381   swig_callbackOnStyleChange = 0;
2382   swig_callbackOnAccessibilityActivated = 0;
2383   swig_callbackOnAccessibilityPan = 0;
2384   swig_callbackOnAccessibilityValueChange = 0;
2385   swig_callbackOnAccessibilityZoom = 0;
2386   swig_callbackOnKeyInputFocusGained = 0;
2387   swig_callbackOnKeyInputFocusLost = 0;
2388   swig_callbackGetNextKeyboardFocusableActor = 0;
2389   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2390   swig_callbackOnKeyboardEnter = 0;
2391   swig_callbackOnPinch = 0;
2392   swig_callbackOnPan = 0;
2393   swig_callbackOnTap = 0;
2394   swig_callbackOnLongPress = 0;
2395   swig_callbackSignalConnected = 0;
2396   swig_callbackSignalDisconnected = 0;
2397 }
2398
2399 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2400   swig_init_callbacks();
2401 }
2402
2403 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2404
2405 }
2406
2407
2408 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2409   unsigned int c_result = SwigValueInit< unsigned int >() ;
2410   unsigned int jresult = 0 ;
2411
2412   if (!swig_callbackGetNumberOfItems) {
2413     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2414   } else {
2415     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2416     c_result = (unsigned int)jresult;
2417   }
2418   return c_result;
2419 }
2420
2421 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2422   Dali::Actor c_result ;
2423   void * jresult = 0 ;
2424   unsigned int jitemId  ;
2425
2426   if (!swig_callbackNewItem) {
2427     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2428   } else {
2429     jitemId = itemId;
2430     jresult = (void *) swig_callbackNewItem(jitemId);
2431     if (!jresult) {
2432       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2433       return c_result;
2434     }
2435     c_result = *(Dali::Actor *)jresult;
2436   }
2437   return c_result;
2438 }
2439
2440 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2441   unsigned int jitemId  ;
2442   void * jactor  ;
2443
2444   if (!swig_callbackItemReleased) {
2445     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2446     return;
2447   } else {
2448     jitemId = itemId;
2449     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2450     swig_callbackItemReleased(jitemId, jactor);
2451   }
2452 }
2453
2454 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2455   return Dali::Toolkit::ItemFactory::GetExtension();
2456 }
2457
2458 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2459   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2460   swig_callbackNewItem = callbackNewItem;
2461   swig_callbackItemReleased = callbackItemReleased;
2462 }
2463
2464 void SwigDirector_ItemFactory::swig_init_callbacks() {
2465   swig_callbackGetNumberOfItems = 0;
2466   swig_callbackNewItem = 0;
2467   swig_callbackItemReleased = 0;
2468 }
2469
2470 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2471   swig_init_callbacks();
2472 }
2473
2474 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2475
2476 }
2477
2478
2479 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2480   Dali::Actor c_result ;
2481   void * jresult = 0 ;
2482   void * jcurrent  ;
2483   void * jproposed  ;
2484   int jdirection  ;
2485
2486   if (!swig_callbackGetNextFocusableActor) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2488   } else {
2489     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2490     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2491     jdirection = (int)direction;
2492     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2493     if (!jresult) {
2494       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__);
2495       return c_result;
2496     }
2497     c_result = *(Dali::Actor *)jresult;
2498   }
2499   return c_result;
2500 }
2501
2502 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2503   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2504 }
2505
2506 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2507   swig_callbackGetNextFocusableActor = 0;
2508 }
2509
2510 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2511   swig_callbackOnUpdate = 0;
2512 }
2513
2514 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2515
2516 }
2517
2518 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2519   swig_callbackOnUpdate = callbackUpdate;
2520 }
2521
2522
2523 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2524   void * jcurrent  ;
2525
2526   if (!swig_callbackOnUpdate) {
2527     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2528   } else {
2529     Dali::UpdateProxy* proxy = &updateProxy;
2530     jcurrent = (void *)proxy;
2531     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2532     if (!jcurrent) {
2533       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2534       return;
2535     }
2536   }
2537   return;
2538 }
2539
2540
2541 #ifdef __cplusplus
2542 extern "C" {
2543 #endif
2544
2545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2546   void * jresult ;
2547   floatp *result = 0 ;
2548
2549   {
2550     try {
2551       result = (floatp *)new_floatp();
2552     } catch (std::out_of_range& e) {
2553       {
2554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (std::exception& e) {
2557       {
2558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2559       };
2560     } catch (DaliException e) {
2561       {
2562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2563       };
2564     } catch (...) {
2565       {
2566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2567       };
2568     }
2569   }
2570   jresult = (void *)result;
2571   return jresult;
2572 }
2573
2574
2575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2576   floatp *arg1 = (floatp *) 0 ;
2577
2578   arg1 = (floatp *)jarg1;
2579   {
2580     try {
2581       delete_floatp(arg1);
2582     } catch (std::out_of_range& e) {
2583       {
2584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2585       };
2586     } catch (std::exception& e) {
2587       {
2588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2589       };
2590     } catch (Dali::DaliException e) {
2591       {
2592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2593       };
2594     } catch (...) {
2595       {
2596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2597       };
2598     }
2599   }
2600
2601 }
2602
2603
2604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2605   floatp *arg1 = (floatp *) 0 ;
2606   float arg2 ;
2607
2608   arg1 = (floatp *)jarg1;
2609   arg2 = (float)jarg2;
2610   {
2611     try {
2612       floatp_assign(arg1,arg2);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2620       };
2621     } catch (Dali::DaliException e) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2624       };
2625     } catch (...) {
2626       {
2627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2628       };
2629     }
2630   }
2631
2632 }
2633
2634
2635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2636   float jresult ;
2637   floatp *arg1 = (floatp *) 0 ;
2638   float result;
2639
2640   arg1 = (floatp *)jarg1;
2641   {
2642     try {
2643       result = (float)floatp_value(arg1);
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2651       };
2652     } catch (DaliException e) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2659       };
2660     }
2661   }
2662   jresult = result;
2663   return jresult;
2664 }
2665
2666
2667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2668   void * jresult ;
2669   floatp *arg1 = (floatp *) 0 ;
2670   float *result = 0 ;
2671
2672   arg1 = (floatp *)jarg1;
2673   {
2674     try {
2675       result = (float *)floatp_cast(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2683       };
2684     } catch (Dali::DaliException e) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2687       };
2688     } catch (...) {
2689       {
2690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2691       };
2692     }
2693   }
2694
2695   jresult = (void *)result;
2696   return jresult;
2697 }
2698
2699
2700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2701   void * jresult ;
2702   float *arg1 = (float *) 0 ;
2703   floatp *result = 0 ;
2704
2705   arg1 = (float *)jarg1;
2706   {
2707     try {
2708       result = (floatp *)floatp_frompointer(arg1);
2709     } catch (std::out_of_range& e) {
2710       {
2711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (std::exception& e) {
2714       {
2715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2716       };
2717     } catch (Dali::DaliException e) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2720       };
2721     } catch (...) {
2722       {
2723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2724       };
2725     }
2726   }
2727
2728   jresult = (void *)result;
2729   return jresult;
2730 }
2731
2732
2733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2734   void * jresult ;
2735   intp *result = 0 ;
2736
2737   {
2738     try {
2739       result = (intp *)new_intp();
2740     } catch (std::out_of_range& e) {
2741       {
2742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (std::exception& e) {
2745       {
2746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2747       };
2748     } catch (Dali::DaliException e) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2751       };
2752     } catch (...) {
2753       {
2754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2755       };
2756     }
2757   }
2758
2759   jresult = (void *)result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2765   intp *arg1 = (intp *) 0 ;
2766
2767   arg1 = (intp *)jarg1;
2768   {
2769     try {
2770       delete_intp(arg1);
2771     } catch (std::out_of_range& e) {
2772       {
2773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2774       };
2775     } catch (std::exception& e) {
2776       {
2777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2778       };
2779     } catch (Dali::DaliException e) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2782       };
2783     } catch (...) {
2784       {
2785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2786       };
2787     }
2788   }
2789
2790 }
2791
2792
2793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2794   intp *arg1 = (intp *) 0 ;
2795   int arg2 ;
2796
2797   arg1 = (intp *)jarg1;
2798   arg2 = (int)jarg2;
2799   {
2800     try {
2801       intp_assign(arg1,arg2);
2802     } catch (std::out_of_range& e) {
2803       {
2804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (std::exception& e) {
2807       {
2808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2809       };
2810     } catch (Dali::DaliException e) {
2811       {
2812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2813       };
2814     } catch (...) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2817       };
2818     }
2819   }
2820
2821 }
2822
2823
2824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2825   int jresult ;
2826   intp *arg1 = (intp *) 0 ;
2827   int result;
2828
2829   arg1 = (intp *)jarg1;
2830   {
2831     try {
2832       result = (int)intp_value(arg1);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2840       };
2841     } catch (Dali::DaliException e) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2844       };
2845     } catch (...) {
2846       {
2847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2848       };
2849     }
2850   }
2851
2852   jresult = result;
2853   return jresult;
2854 }
2855
2856
2857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2858   void * jresult ;
2859   intp *arg1 = (intp *) 0 ;
2860   int *result = 0 ;
2861
2862   arg1 = (intp *)jarg1;
2863   {
2864     try {
2865       result = (int *)intp_cast(arg1);
2866     } catch (std::out_of_range& e) {
2867       {
2868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2869       };
2870     } catch (std::exception& e) {
2871       {
2872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2873       };
2874     } catch (Dali::DaliException e) {
2875       {
2876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2877       };
2878     } catch (...) {
2879       {
2880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2881       };
2882     }
2883   }
2884
2885   jresult = (void *)result;
2886   return jresult;
2887 }
2888
2889
2890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2891   void * jresult ;
2892   int *arg1 = (int *) 0 ;
2893   intp *result = 0 ;
2894
2895   arg1 = (int *)jarg1;
2896   {
2897     try {
2898       result = (intp *)intp_frompointer(arg1);
2899     } catch (std::out_of_range& e) {
2900       {
2901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2902       };
2903     } catch (std::exception& e) {
2904       {
2905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2906       };
2907     } catch (Dali::DaliException e) {
2908       {
2909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2910       };
2911     } catch (...) {
2912       {
2913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2914       };
2915     }
2916   }
2917
2918   jresult = (void *)result;
2919   return jresult;
2920 }
2921
2922
2923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2924   void * jresult ;
2925   doublep *result = 0 ;
2926
2927   {
2928     try {
2929       result = (doublep *)new_doublep();
2930     } catch (std::out_of_range& e) {
2931       {
2932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (std::exception& e) {
2935       {
2936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2937       };
2938     } catch (Dali::DaliException e) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2941       };
2942     } catch (...) {
2943       {
2944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2945       };
2946     }
2947   }
2948
2949   jresult = (void *)result;
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2955   doublep *arg1 = (doublep *) 0 ;
2956
2957   arg1 = (doublep *)jarg1;
2958   {
2959     try {
2960       delete_doublep(arg1);
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2968       };
2969     } catch (Dali::DaliException e) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2976       };
2977     }
2978   }
2979
2980 }
2981
2982
2983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2984   doublep *arg1 = (doublep *) 0 ;
2985   double arg2 ;
2986
2987   arg1 = (doublep *)jarg1;
2988   arg2 = (double)jarg2;
2989   {
2990     try {
2991       doublep_assign(arg1,arg2);
2992     } catch (std::out_of_range& e) {
2993       {
2994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2995       };
2996     } catch (std::exception& e) {
2997       {
2998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (Dali::DaliException e) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010
3011 }
3012
3013
3014 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3015   double jresult ;
3016   doublep *arg1 = (doublep *) 0 ;
3017   double result;
3018
3019   arg1 = (doublep *)jarg1;
3020   {
3021     try {
3022       result = (double)doublep_value(arg1);
3023     } catch (std::out_of_range& e) {
3024       {
3025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3026       };
3027     } catch (std::exception& e) {
3028       {
3029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3030       };
3031     } catch (Dali::DaliException e) {
3032       {
3033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3038       };
3039     }
3040   }
3041
3042   jresult = result;
3043   return jresult;
3044 }
3045
3046
3047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3048   void * jresult ;
3049   doublep *arg1 = (doublep *) 0 ;
3050   double *result = 0 ;
3051
3052   arg1 = (doublep *)jarg1;
3053   {
3054     try {
3055       result = (double *)doublep_cast(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3063       };
3064     } catch (Dali::DaliException e) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3067       };
3068     } catch (...) {
3069       {
3070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3071       };
3072     }
3073   }
3074
3075   jresult = (void *)result;
3076   return jresult;
3077 }
3078
3079
3080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3081   void * jresult ;
3082   double *arg1 = (double *) 0 ;
3083   doublep *result = 0 ;
3084
3085   arg1 = (double *)jarg1;
3086   {
3087     try {
3088       result = (doublep *)doublep_frompointer(arg1);
3089     } catch (std::out_of_range& e) {
3090       {
3091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3092       };
3093     } catch (std::exception& e) {
3094       {
3095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3096       };
3097     } catch (Dali::DaliException e) {
3098       {
3099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3100       };
3101     } catch (...) {
3102       {
3103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3104       };
3105     }
3106   }
3107
3108   jresult = (void *)result;
3109   return jresult;
3110 }
3111
3112
3113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3114   void * jresult ;
3115   uintp *result = 0 ;
3116
3117   {
3118     try {
3119       result = (uintp *)new_uintp();
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (Dali::DaliException e) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3145   uintp *arg1 = (uintp *) 0 ;
3146
3147   arg1 = (uintp *)jarg1;
3148   {
3149     try {
3150       delete_uintp(arg1);
3151     } catch (std::out_of_range& e) {
3152       {
3153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3154       };
3155     } catch (std::exception& e) {
3156       {
3157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3158       };
3159     } catch (Dali::DaliException e) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3166       };
3167     }
3168   }
3169
3170 }
3171
3172
3173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3174   uintp *arg1 = (uintp *) 0 ;
3175   unsigned int arg2 ;
3176
3177   arg1 = (uintp *)jarg1;
3178   arg2 = (unsigned int)jarg2;
3179   {
3180     try {
3181       uintp_assign(arg1,arg2);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (Dali::DaliException e) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3193       };
3194     } catch (...) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3197       };
3198     }
3199   }
3200
3201 }
3202
3203
3204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3205   unsigned int jresult ;
3206   uintp *arg1 = (uintp *) 0 ;
3207   unsigned int result;
3208
3209   arg1 = (uintp *)jarg1;
3210   {
3211     try {
3212       result = (unsigned int)uintp_value(arg1);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (Dali::DaliException e) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3228       };
3229     }
3230   }
3231
3232   jresult = result;
3233   return jresult;
3234 }
3235
3236
3237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3238   void * jresult ;
3239   uintp *arg1 = (uintp *) 0 ;
3240   unsigned int *result = 0 ;
3241
3242   arg1 = (uintp *)jarg1;
3243   {
3244     try {
3245       result = (unsigned int *)uintp_cast(arg1);
3246     } catch (std::out_of_range& e) {
3247       {
3248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3249       };
3250     } catch (std::exception& e) {
3251       {
3252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3253       };
3254     } catch (Dali::DaliException e) {
3255       {
3256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3257       };
3258     } catch (...) {
3259       {
3260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3261       };
3262     }
3263   }
3264
3265   jresult = (void *)result;
3266   return jresult;
3267 }
3268
3269
3270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3271   void * jresult ;
3272   unsigned int *arg1 = (unsigned int *) 0 ;
3273   uintp *result = 0 ;
3274
3275   arg1 = (unsigned int *)jarg1;
3276   {
3277     try {
3278       result = (uintp *)uintp_frompointer(arg1);
3279     } catch (std::out_of_range& e) {
3280       {
3281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3282       };
3283     } catch (std::exception& e) {
3284       {
3285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3286       };
3287     } catch (Dali::DaliException e) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3290       };
3291     } catch (...) {
3292       {
3293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3294       };
3295     }
3296   }
3297
3298   jresult = (void *)result;
3299   return jresult;
3300 }
3301
3302
3303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3304   void * jresult ;
3305   ushortp *result = 0 ;
3306
3307   {
3308     try {
3309       result = (ushortp *)new_ushortp();
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (Dali::DaliException e) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3321       };
3322     } catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328
3329   jresult = (void *)result;
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3335   ushortp *arg1 = (ushortp *) 0 ;
3336
3337   arg1 = (ushortp *)jarg1;
3338   {
3339     try {
3340       delete_ushortp(arg1);
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3348       };
3349     } catch (Dali::DaliException e) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3356       };
3357     }
3358   }
3359
3360 }
3361
3362
3363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3364   ushortp *arg1 = (ushortp *) 0 ;
3365   unsigned short arg2 ;
3366
3367   arg1 = (ushortp *)jarg1;
3368   arg2 = (unsigned short)jarg2;
3369   {
3370     try {
3371       ushortp_assign(arg1,arg2);
3372     } catch (std::out_of_range& e) {
3373       {
3374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3375       };
3376     } catch (std::exception& e) {
3377       {
3378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3379       };
3380     } catch (Dali::DaliException e) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3383       };
3384     } catch (...) {
3385       {
3386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3387       };
3388     }
3389   }
3390
3391 }
3392
3393
3394 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3395   unsigned short jresult ;
3396   ushortp *arg1 = (ushortp *) 0 ;
3397   unsigned short result;
3398
3399   arg1 = (ushortp *)jarg1;
3400   {
3401     try {
3402       result = (unsigned short)ushortp_value(arg1);
3403     } catch (std::out_of_range& e) {
3404       {
3405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3406       };
3407     } catch (std::exception& e) {
3408       {
3409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3410       };
3411     } catch (Dali::DaliException e) {
3412       {
3413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3418       };
3419     }
3420   }
3421
3422   jresult = result;
3423   return jresult;
3424 }
3425
3426
3427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3428   void * jresult ;
3429   ushortp *arg1 = (ushortp *) 0 ;
3430   unsigned short *result = 0 ;
3431
3432   arg1 = (ushortp *)jarg1;
3433   {
3434     try {
3435       result = (unsigned short *)ushortp_cast(arg1);
3436     } catch (std::out_of_range& e) {
3437       {
3438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (std::exception& e) {
3441       {
3442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3443       };
3444     } catch (Dali::DaliException e) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3447       };
3448     } catch (...) {
3449       {
3450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3451       };
3452     }
3453   }
3454
3455   jresult = (void *)result;
3456   return jresult;
3457 }
3458
3459
3460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3461   void * jresult ;
3462   unsigned short *arg1 = (unsigned short *) 0 ;
3463   ushortp *result = 0 ;
3464
3465   arg1 = (unsigned short *)jarg1;
3466   {
3467     try {
3468       result = (ushortp *)ushortp_frompointer(arg1);
3469     } catch (std::out_of_range& e) {
3470       {
3471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3472       };
3473     } catch (std::exception& e) {
3474       {
3475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3476       };
3477     } catch (Dali::DaliException e) {
3478       {
3479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3480       };
3481     } catch (...) {
3482       {
3483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3484       };
3485     }
3486   }
3487
3488   jresult = (void *)result;
3489   return jresult;
3490 }
3491
3492
3493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3494   unsigned int jresult ;
3495   int arg1 ;
3496   unsigned int result;
3497
3498   arg1 = (int)jarg1;
3499   {
3500     try {
3501       result = (unsigned int)int_to_uint(arg1);
3502     } catch (std::out_of_range& e) {
3503       {
3504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (std::exception& e) {
3507       {
3508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3509       };
3510     } catch (Dali::DaliException e) {
3511       {
3512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3513       };
3514     } catch (...) {
3515       {
3516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3517       };
3518     }
3519   }
3520
3521   jresult = result;
3522   return jresult;
3523 }
3524
3525
3526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3527   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3528
3529   arg1 = (Dali::RefObject *)jarg1;
3530   {
3531     try {
3532       (arg1)->Reference();
3533     } catch (std::out_of_range& e) {
3534       {
3535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3536       };
3537     } catch (std::exception& e) {
3538       {
3539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3540       };
3541     } catch (Dali::DaliException e) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3544       };
3545     } catch (...) {
3546       {
3547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3548       };
3549     }
3550   }
3551
3552 }
3553
3554
3555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3556   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3557
3558   arg1 = (Dali::RefObject *)jarg1;
3559   {
3560     try {
3561       (arg1)->Unreference();
3562     } catch (std::out_of_range& e) {
3563       {
3564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3565       };
3566     } catch (std::exception& e) {
3567       {
3568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3569       };
3570     } catch (Dali::DaliException e) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3573       };
3574     } catch (...) {
3575       {
3576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3577       };
3578     }
3579   }
3580
3581 }
3582
3583
3584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3585   int jresult ;
3586   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3587   int result;
3588
3589   arg1 = (Dali::RefObject *)jarg1;
3590   {
3591     try {
3592       result = (int)(arg1)->ReferenceCount();
3593     } catch (std::out_of_range& e) {
3594       {
3595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3596       };
3597     } catch (std::exception& e) {
3598       {
3599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3600       };
3601     } catch (Dali::DaliException e) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3604       };
3605     } catch (...) {
3606       {
3607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3608       };
3609     }
3610   }
3611
3612   jresult = result;
3613   return jresult;
3614 }
3615
3616
3617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3618   void * jresult ;
3619   Dali::Any *result = 0 ;
3620
3621   {
3622     try {
3623       result = (Dali::Any *)new Dali::Any();
3624     } catch (std::out_of_range& e) {
3625       {
3626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (std::exception& e) {
3629       {
3630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (Dali::DaliException e) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642
3643   jresult = (void *)result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3649   Dali::Any *arg1 = (Dali::Any *) 0 ;
3650
3651   arg1 = (Dali::Any *)jarg1;
3652   {
3653     try {
3654       delete arg1;
3655     } catch (std::out_of_range& e) {
3656       {
3657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3658       };
3659     } catch (std::exception& e) {
3660       {
3661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3662       };
3663     } catch (Dali::DaliException e) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3666       };
3667     } catch (...) {
3668       {
3669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3670       };
3671     }
3672   }
3673
3674 }
3675
3676
3677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3678   char *arg1 = (char *) 0 ;
3679
3680   arg1 = (char *)jarg1;
3681   {
3682     try {
3683       Dali::Any::AssertAlways((char const *)arg1);
3684     } catch (std::out_of_range& e) {
3685       {
3686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3687       };
3688     } catch (std::exception& e) {
3689       {
3690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3691       };
3692     } catch (Dali::DaliException e) {
3693       {
3694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3695       };
3696     } catch (...) {
3697       {
3698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3699       };
3700     }
3701   }
3702
3703 }
3704
3705
3706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3707   void * jresult ;
3708   Dali::Any *arg1 = 0 ;
3709   Dali::Any *result = 0 ;
3710
3711   arg1 = (Dali::Any *)jarg1;
3712   if (!arg1) {
3713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3714     return 0;
3715   }
3716   {
3717     try {
3718       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3719     } catch (std::out_of_range& e) {
3720       {
3721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3722       };
3723     } catch (std::exception& e) {
3724       {
3725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3726       };
3727     } catch (Dali::DaliException e) {
3728       {
3729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3730       };
3731     } catch (...) {
3732       {
3733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3734       };
3735     }
3736   }
3737
3738   jresult = (void *)result;
3739   return jresult;
3740 }
3741
3742
3743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3744   void * jresult ;
3745   Dali::Any *arg1 = (Dali::Any *) 0 ;
3746   Dali::Any *arg2 = 0 ;
3747   Dali::Any *result = 0 ;
3748
3749   arg1 = (Dali::Any *)jarg1;
3750   arg2 = (Dali::Any *)jarg2;
3751   if (!arg2) {
3752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3753     return 0;
3754   }
3755   {
3756     try {
3757       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (Dali::DaliException e) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3769       };
3770     } catch (...) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3773       };
3774     }
3775   }
3776
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3783   void * jresult ;
3784   Dali::Any *arg1 = (Dali::Any *) 0 ;
3785   std::type_info *result = 0 ;
3786
3787   arg1 = (Dali::Any *)jarg1;
3788   {
3789     try {
3790       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3791     } catch (std::out_of_range& e) {
3792       {
3793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3794       };
3795     } catch (std::exception& e) {
3796       {
3797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3798       };
3799     } catch (Dali::DaliException e) {
3800       {
3801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3802       };
3803     } catch (...) {
3804       {
3805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3806       };
3807     }
3808   }
3809
3810   jresult = (void *)result;
3811   return jresult;
3812 }
3813
3814
3815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3816   unsigned int jresult ;
3817   Dali::Any *arg1 = (Dali::Any *) 0 ;
3818   bool result;
3819
3820   arg1 = (Dali::Any *)jarg1;
3821   {
3822     try {
3823       result = (bool)((Dali::Any const *)arg1)->Empty();
3824     } catch (std::out_of_range& e) {
3825       {
3826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3827       };
3828     } catch (std::exception& e) {
3829       {
3830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3831       };
3832     } catch (Dali::DaliException e) {
3833       {
3834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3835       };
3836     } catch (...) {
3837       {
3838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3839       };
3840     }
3841   }
3842
3843   jresult = result;
3844   return jresult;
3845 }
3846
3847
3848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3849   void * jresult ;
3850   std::type_info *arg1 = 0 ;
3851   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3852   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3853   Dali::Any::AnyContainerBase *result = 0 ;
3854
3855   arg1 = (std::type_info *)jarg1;
3856   if (!arg1) {
3857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3858     return 0;
3859   }
3860   arg2 = (Dali::Any::CloneFunc)jarg2;
3861   arg3 = (Dali::Any::DeleteFunc)jarg3;
3862   {
3863     try {
3864       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3865     } catch (std::out_of_range& e) {
3866       {
3867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3868       };
3869     } catch (std::exception& e) {
3870       {
3871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (Dali::DaliException e) {
3874       {
3875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883
3884   jresult = (void *)result;
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3890   void * jresult ;
3891   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3892   std::type_info *result = 0 ;
3893
3894   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3895   {
3896     try {
3897       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3898     } catch (std::out_of_range& e) {
3899       {
3900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (std::exception& e) {
3903       {
3904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3905       };
3906     } catch (Dali::DaliException e) {
3907       {
3908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3909       };
3910     } catch (...) {
3911       {
3912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3913       };
3914     }
3915   }
3916
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3923   void * jresult ;
3924   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3925   ::std::type_info *result = 0 ;
3926
3927   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3928   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   arg2 = (Dali::Any::CloneFunc)jarg2;
3940   if (arg1) (arg1)->mCloneFunc = arg2;
3941 }
3942
3943
3944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3945   void * jresult ;
3946   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3947   Dali::Any::CloneFunc result;
3948
3949   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3950   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3957   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3958   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3959
3960   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3961   arg2 = (Dali::Any::DeleteFunc)jarg2;
3962   if (arg1) (arg1)->mDeleteFunc = arg2;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   Dali::Any::DeleteFunc result;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980
3981   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3982   {
3983     try {
3984       delete arg1;
3985     } catch (std::out_of_range& e) {
3986       {
3987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3988       };
3989     } catch (std::exception& e) {
3990       {
3991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3992       };
3993     } catch (Dali::DaliException e) {
3994       {
3995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3996       };
3997     } catch (...) {
3998       {
3999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4000       };
4001     }
4002   }
4003
4004 }
4005
4006
4007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4008   Dali::Any *arg1 = (Dali::Any *) 0 ;
4009   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4010
4011   arg1 = (Dali::Any *)jarg1;
4012   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4013   if (arg1) (arg1)->mContainer = arg2;
4014 }
4015
4016
4017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4018   void * jresult ;
4019   Dali::Any *arg1 = (Dali::Any *) 0 ;
4020   Dali::Any::AnyContainerBase *result = 0 ;
4021
4022   arg1 = (Dali::Any *)jarg1;
4023   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4024   jresult = (void *)result;
4025   return jresult;
4026 }
4027
4028
4029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4030   char *arg1 = (char *) 0 ;
4031   char *arg2 = (char *) 0 ;
4032
4033   arg1 = (char *)jarg1;
4034   arg2 = (char *)jarg2;
4035   {
4036     try {
4037       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4038     } catch (std::out_of_range& e) {
4039       {
4040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4041       };
4042     } catch (std::exception& e) {
4043       {
4044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4045       };
4046     } catch (Dali::DaliException e) {
4047       {
4048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4049       };
4050     } catch (...) {
4051       {
4052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4053       };
4054     }
4055   }
4056
4057 }
4058
4059
4060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4061   void * jresult ;
4062   char *arg1 = (char *) 0 ;
4063   char *arg2 = (char *) 0 ;
4064   Dali::DaliException *result = 0 ;
4065
4066   arg1 = (char *)jarg1;
4067   arg2 = (char *)jarg2;
4068   {
4069     try {
4070       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4071     } catch (std::out_of_range& e) {
4072       {
4073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4074       };
4075     } catch (std::exception& e) {
4076       {
4077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4078       };
4079     } catch (Dali::DaliException e) {
4080       {
4081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4082       };
4083     } catch (...) {
4084       {
4085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4086       };
4087     }
4088   }
4089
4090   jresult = (void *)result;
4091   return jresult;
4092 }
4093
4094
4095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4096   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4097   std::string arg2 = std::string(jarg2);
4098
4099   arg1 = (Dali::DaliException *)jarg1;
4100   {
4101     if (!arg2.empty()) {
4102       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4103     } else {
4104       arg1->location = 0;
4105     }
4106   }
4107 }
4108
4109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4110   char * jresult ;
4111   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4112   char *result = 0 ;
4113
4114   arg1 = (Dali::DaliException *)jarg1;
4115   result = (char *) ((arg1)->location);
4116   jresult = SWIG_csharp_string_callback((const char *)result);
4117   return jresult;
4118 }
4119
4120
4121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4122   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4123   std::string arg2 = std::string(jarg2);
4124
4125   arg1 = (Dali::DaliException *)jarg1;
4126   {
4127     if (!arg2.empty()) {
4128       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4129     } else {
4130       arg1->condition = 0;
4131     }
4132   }
4133 }
4134
4135
4136 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4137   char * jresult ;
4138   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4139   char *result = 0 ;
4140
4141   arg1 = (Dali::DaliException *)jarg1;
4142   result = (char *) ((arg1)->condition);
4143   jresult = SWIG_csharp_string_callback((const char *)result);
4144   return jresult;
4145 }
4146
4147
4148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4149   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4150
4151   arg1 = (Dali::DaliException *)jarg1;
4152   {
4153     try {
4154       delete arg1;
4155     } catch (std::out_of_range& e) {
4156       {
4157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4158       };
4159     } catch (std::exception& e) {
4160       {
4161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4162       };
4163     } catch (Dali::DaliException e) {
4164       {
4165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4166       };
4167     } catch (...) {
4168       {
4169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4170       };
4171     }
4172   }
4173
4174 }
4175
4176
4177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4178   void * jresult ;
4179   Dali::Vector2 *result = 0 ;
4180
4181   {
4182     try {
4183       result = (Dali::Vector2 *)new Dali::Vector2();
4184     } catch (std::out_of_range& e) {
4185       {
4186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4187       };
4188     } catch (std::exception& e) {
4189       {
4190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4191       };
4192     } catch (Dali::DaliException e) {
4193       {
4194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4195       };
4196     } catch (...) {
4197       {
4198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4199       };
4200     }
4201   }
4202
4203   jresult = (void *)result;
4204   return jresult;
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4209   void * jresult ;
4210   float arg1 ;
4211   float arg2 ;
4212   Dali::Vector2 *result = 0 ;
4213
4214   arg1 = (float)jarg1;
4215   arg2 = (float)jarg2;
4216   {
4217     try {
4218       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4219     } catch (std::out_of_range& e) {
4220       {
4221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4222       };
4223     } catch (std::exception& e) {
4224       {
4225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (Dali::DaliException e) {
4228       {
4229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4230       };
4231     } catch (...) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4234       };
4235     }
4236   }
4237
4238   jresult = (void *)result;
4239   return jresult;
4240 }
4241
4242
4243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4244   void * jresult ;
4245   float *arg1 = (float *) 0 ;
4246   Dali::Vector2 *result = 0 ;
4247
4248   arg1 = jarg1;
4249   {
4250     try {
4251       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4252     } catch (std::out_of_range& e) {
4253       {
4254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4255       };
4256     } catch (std::exception& e) {
4257       {
4258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4259       };
4260     } catch (Dali::DaliException e) {
4261       {
4262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4263       };
4264     } catch (...) {
4265       {
4266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4267       };
4268     }
4269   }
4270
4271   jresult = (void *)result;
4272
4273
4274   return jresult;
4275 }
4276
4277
4278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4279   void * jresult ;
4280   Dali::Vector3 *arg1 = 0 ;
4281   Dali::Vector2 *result = 0 ;
4282
4283   arg1 = (Dali::Vector3 *)jarg1;
4284   if (!arg1) {
4285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4286     return 0;
4287   }
4288   {
4289     try {
4290       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (Dali::DaliException e) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309
4310   jresult = (void *)result;
4311   return jresult;
4312 }
4313
4314
4315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4316   void * jresult ;
4317   Dali::Vector4 *arg1 = 0 ;
4318   Dali::Vector2 *result = 0 ;
4319
4320   arg1 = (Dali::Vector4 *)jarg1;
4321   if (!arg1) {
4322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4323     return 0;
4324   }
4325   {
4326     try {
4327       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4328     } catch (std::out_of_range& e) {
4329       {
4330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (std::exception& e) {
4333       {
4334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (Dali::DaliException e) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4339       };
4340     } catch (...) {
4341       {
4342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4343       };
4344     }
4345   }
4346
4347   jresult = (void *)result;
4348   return jresult;
4349 }
4350
4351
4352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4353   void * jresult ;
4354   Dali::Vector2 *result = 0 ;
4355
4356   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4363   void * jresult ;
4364   Dali::Vector2 *result = 0 ;
4365
4366   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4367   jresult = (void *)result;
4368   return jresult;
4369 }
4370
4371
4372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4373   void * jresult ;
4374   Dali::Vector2 *result = 0 ;
4375
4376   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4377   jresult = (void *)result;
4378   return jresult;
4379 }
4380
4381
4382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4383   void * jresult ;
4384   Dali::Vector2 *result = 0 ;
4385
4386   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4387   jresult = (void *)result;
4388   return jresult;
4389 }
4390
4391
4392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4393   void * jresult ;
4394   Dali::Vector2 *result = 0 ;
4395
4396   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4397   jresult = (void *)result;
4398   return jresult;
4399 }
4400
4401
4402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4403   void * jresult ;
4404   Dali::Vector2 *result = 0 ;
4405
4406   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4407   jresult = (void *)result;
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4413   void * jresult ;
4414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4415   float *arg2 = (float *) 0 ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   arg1 = (Dali::Vector2 *)jarg1;
4419   arg2 = jarg2;
4420   {
4421     try {
4422       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4423     } catch (std::out_of_range& e) {
4424       {
4425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (std::exception& e) {
4428       {
4429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4430       };
4431     } catch (Dali::DaliException e) {
4432       {
4433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4434       };
4435     } catch (...) {
4436       {
4437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4438       };
4439     }
4440   }
4441
4442   jresult = (void *)result;
4443
4444
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4450   void * jresult ;
4451   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4452   Dali::Vector3 *arg2 = 0 ;
4453   Dali::Vector2 *result = 0 ;
4454
4455   arg1 = (Dali::Vector2 *)jarg1;
4456   arg2 = (Dali::Vector3 *)jarg2;
4457   if (!arg2) {
4458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4459     return 0;
4460   }
4461   {
4462     try {
4463       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4464     } catch (std::out_of_range& e) {
4465       {
4466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4467       };
4468     } catch (std::exception& e) {
4469       {
4470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (Dali::DaliException e) {
4473       {
4474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482
4483   jresult = (void *)result;
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector4 *arg2 = 0 ;
4492   Dali::Vector2 *result = 0 ;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   arg2 = (Dali::Vector4 *)jarg2;
4496   if (!arg2) {
4497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4498     return 0;
4499   }
4500   {
4501     try {
4502       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4503     } catch (std::out_of_range& e) {
4504       {
4505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (std::exception& e) {
4508       {
4509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (Dali::DaliException e) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4514       };
4515     } catch (...) {
4516       {
4517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4518       };
4519     }
4520   }
4521
4522   jresult = (void *)result;
4523   return jresult;
4524 }
4525
4526
4527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4528   void * jresult ;
4529   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4530   Dali::Vector2 *arg2 = 0 ;
4531   Dali::Vector2 result;
4532
4533   arg1 = (Dali::Vector2 *)jarg1;
4534   arg2 = (Dali::Vector2 *)jarg2;
4535   if (!arg2) {
4536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4537     return 0;
4538   }
4539   {
4540     try {
4541       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4542     } catch (std::out_of_range& e) {
4543       {
4544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (std::exception& e) {
4547       {
4548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (Dali::DaliException e) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4553       };
4554     } catch (...) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4557       };
4558     }
4559   }
4560
4561   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 *arg2 = 0 ;
4570   Dali::Vector2 *result = 0 ;
4571
4572   arg1 = (Dali::Vector2 *)jarg1;
4573   arg2 = (Dali::Vector2 *)jarg2;
4574   if (!arg2) {
4575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4576     return 0;
4577   }
4578   {
4579     try {
4580       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (Dali::DaliException e) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4592       };
4593     } catch (...) {
4594       {
4595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4596       };
4597     }
4598   }
4599
4600   jresult = (void *)result;
4601   return jresult;
4602 }
4603
4604
4605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4606   void * jresult ;
4607   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4608   Dali::Vector2 *arg2 = 0 ;
4609   Dali::Vector2 result;
4610
4611   arg1 = (Dali::Vector2 *)jarg1;
4612   arg2 = (Dali::Vector2 *)jarg2;
4613   if (!arg2) {
4614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4615     return 0;
4616   }
4617   {
4618     try {
4619       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4620     } catch (std::out_of_range& e) {
4621       {
4622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4623       };
4624     } catch (std::exception& e) {
4625       {
4626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (Dali::DaliException e) {
4629       {
4630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638
4639   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4640   return jresult;
4641 }
4642
4643
4644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4645   void * jresult ;
4646   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4647   Dali::Vector2 *arg2 = 0 ;
4648   Dali::Vector2 *result = 0 ;
4649
4650   arg1 = (Dali::Vector2 *)jarg1;
4651   arg2 = (Dali::Vector2 *)jarg2;
4652   if (!arg2) {
4653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4654     return 0;
4655   }
4656   {
4657     try {
4658       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4659     } catch (std::out_of_range& e) {
4660       {
4661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (std::exception& e) {
4664       {
4665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (Dali::DaliException e) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4674       };
4675     }
4676   }
4677
4678   jresult = (void *)result;
4679   return jresult;
4680 }
4681
4682
4683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4684   void * jresult ;
4685   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4686   Dali::Vector2 *arg2 = 0 ;
4687   Dali::Vector2 result;
4688
4689   arg1 = (Dali::Vector2 *)jarg1;
4690   arg2 = (Dali::Vector2 *)jarg2;
4691   if (!arg2) {
4692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4693     return 0;
4694   }
4695   {
4696     try {
4697       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4698     } catch (std::out_of_range& e) {
4699       {
4700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (std::exception& e) {
4703       {
4704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4705       };
4706     } catch (Dali::DaliException e) {
4707       {
4708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4709       };
4710     } catch (...) {
4711       {
4712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4713       };
4714     }
4715   }
4716
4717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4723   void * jresult ;
4724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4725   float arg2 ;
4726   Dali::Vector2 result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   arg2 = (float)jarg2;
4730   {
4731     try {
4732       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4733     } catch (std::out_of_range& e) {
4734       {
4735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (std::exception& e) {
4738       {
4739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4740       };
4741     } catch (Dali::DaliException e) {
4742       {
4743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4744       };
4745     } catch (...) {
4746       {
4747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4748       };
4749     }
4750   }
4751
4752   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4753   return jresult;
4754 }
4755
4756
4757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4758   void * jresult ;
4759   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4760   Dali::Vector2 *arg2 = 0 ;
4761   Dali::Vector2 *result = 0 ;
4762
4763   arg1 = (Dali::Vector2 *)jarg1;
4764   arg2 = (Dali::Vector2 *)jarg2;
4765   if (!arg2) {
4766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4767     return 0;
4768   }
4769   {
4770     try {
4771       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4772     } catch (std::out_of_range& e) {
4773       {
4774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4775       };
4776     } catch (std::exception& e) {
4777       {
4778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4779       };
4780     } catch (Dali::DaliException e) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4787       };
4788     }
4789   }
4790
4791   jresult = (void *)result;
4792   return jresult;
4793 }
4794
4795
4796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4797   void * jresult ;
4798   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4799   float arg2 ;
4800   Dali::Vector2 *result = 0 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (float)jarg2;
4804   {
4805     try {
4806       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4807     } catch (std::out_of_range& e) {
4808       {
4809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4810       };
4811     } catch (std::exception& e) {
4812       {
4813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4814       };
4815     } catch (Dali::DaliException e) {
4816       {
4817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4818       };
4819     } catch (...) {
4820       {
4821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4822       };
4823     }
4824   }
4825
4826   jresult = (void *)result;
4827   return jresult;
4828 }
4829
4830
4831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4832   void * jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   Dali::Vector2 *arg2 = 0 ;
4835   Dali::Vector2 result;
4836
4837   arg1 = (Dali::Vector2 *)jarg1;
4838   arg2 = (Dali::Vector2 *)jarg2;
4839   if (!arg2) {
4840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4841     return 0;
4842   }
4843   {
4844     try {
4845       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4846     } catch (std::out_of_range& e) {
4847       {
4848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (std::exception& e) {
4851       {
4852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (Dali::DaliException e) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4857       };
4858     } catch (...) {
4859       {
4860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4861       };
4862     }
4863   }
4864
4865   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4866   return jresult;
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4873   float arg2 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   arg2 = (float)jarg2;
4878   {
4879     try {
4880       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4881     } catch (std::out_of_range& e) {
4882       {
4883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4884       };
4885     } catch (std::exception& e) {
4886       {
4887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4888       };
4889     } catch (Dali::DaliException e) {
4890       {
4891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4892       };
4893     } catch (...) {
4894       {
4895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4896       };
4897     }
4898   }
4899
4900   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4906   void * jresult ;
4907   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4908   Dali::Vector2 *arg2 = 0 ;
4909   Dali::Vector2 *result = 0 ;
4910
4911   arg1 = (Dali::Vector2 *)jarg1;
4912   arg2 = (Dali::Vector2 *)jarg2;
4913   if (!arg2) {
4914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4915     return 0;
4916   }
4917   {
4918     try {
4919       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4920     } catch (std::out_of_range& e) {
4921       {
4922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4923       };
4924     } catch (std::exception& e) {
4925       {
4926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4927       };
4928     } catch (Dali::DaliException e) {
4929       {
4930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4931       };
4932     } catch (...) {
4933       {
4934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4935       };
4936     }
4937   }
4938
4939   jresult = (void *)result;
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4945   void * jresult ;
4946   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4947   float arg2 ;
4948   Dali::Vector2 *result = 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   arg2 = (float)jarg2;
4952   {
4953     try {
4954       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4955     } catch (std::out_of_range& e) {
4956       {
4957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4958       };
4959     } catch (std::exception& e) {
4960       {
4961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4962       };
4963     } catch (Dali::DaliException e) {
4964       {
4965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4966       };
4967     } catch (...) {
4968       {
4969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4970       };
4971     }
4972   }
4973
4974   jresult = (void *)result;
4975   return jresult;
4976 }
4977
4978
4979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4980   void * jresult ;
4981   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4982   Dali::Vector2 result;
4983
4984   arg1 = (Dali::Vector2 *)jarg1;
4985   {
4986     try {
4987       result = ((Dali::Vector2 const *)arg1)->operator -();
4988     } catch (std::out_of_range& e) {
4989       {
4990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4991       };
4992     } catch (std::exception& e) {
4993       {
4994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4995       };
4996     } catch (Dali::DaliException e) {
4997       {
4998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4999       };
5000     } catch (...) {
5001       {
5002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5003       };
5004     }
5005   }
5006
5007   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5008   return jresult;
5009 }
5010
5011
5012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5013   unsigned int jresult ;
5014   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5015   Dali::Vector2 *arg2 = 0 ;
5016   bool result;
5017
5018   arg1 = (Dali::Vector2 *)jarg1;
5019   arg2 = (Dali::Vector2 *)jarg2;
5020   if (!arg2) {
5021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5022     return 0;
5023   }
5024   {
5025     try {
5026       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5027     } catch (std::out_of_range& e) {
5028       {
5029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (std::exception& e) {
5032       {
5033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (Dali::DaliException e) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5038       };
5039     } catch (...) {
5040       {
5041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5042       };
5043     }
5044   }
5045
5046   jresult = result;
5047   return jresult;
5048 }
5049
5050
5051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5052   unsigned int jresult ;
5053   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5054   Dali::Vector2 *arg2 = 0 ;
5055   bool result;
5056
5057   arg1 = (Dali::Vector2 *)jarg1;
5058   arg2 = (Dali::Vector2 *)jarg2;
5059   if (!arg2) {
5060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5061     return 0;
5062   }
5063   {
5064     try {
5065       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5066     } catch (std::out_of_range& e) {
5067       {
5068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (std::exception& e) {
5071       {
5072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (Dali::DaliException e) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084
5085   jresult = result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5091   float jresult ;
5092   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5093   unsigned int arg2 ;
5094   float *result = 0 ;
5095
5096   arg1 = (Dali::Vector2 *)jarg1;
5097   arg2 = (unsigned int)jarg2;
5098   {
5099     try {
5100       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5101     } catch (std::out_of_range& e) {
5102       {
5103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5104       };
5105     } catch (std::exception& e) {
5106       {
5107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (Dali::DaliException e) {
5110       {
5111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119
5120   jresult = *result;
5121   return jresult;
5122 }
5123
5124
5125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5126   float jresult ;
5127   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5128   float result;
5129
5130   arg1 = (Dali::Vector2 *)jarg1;
5131   {
5132     try {
5133       result = (float)((Dali::Vector2 const *)arg1)->Length();
5134     } catch (std::out_of_range& e) {
5135       {
5136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (std::exception& e) {
5139       {
5140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5141       };
5142     } catch (Dali::DaliException e) {
5143       {
5144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5145       };
5146     } catch (...) {
5147       {
5148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5149       };
5150     }
5151   }
5152
5153   jresult = result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5159   float jresult ;
5160   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5161   float result;
5162
5163   arg1 = (Dali::Vector2 *)jarg1;
5164   {
5165     try {
5166       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5167     } catch (std::out_of_range& e) {
5168       {
5169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5170       };
5171     } catch (std::exception& e) {
5172       {
5173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5174       };
5175     } catch (Dali::DaliException e) {
5176       {
5177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5178       };
5179     } catch (...) {
5180       {
5181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5182       };
5183     }
5184   }
5185
5186   jresult = result;
5187   return jresult;
5188 }
5189
5190
5191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5192   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5193
5194   arg1 = (Dali::Vector2 *)jarg1;
5195   {
5196     try {
5197       (arg1)->Normalize();
5198     } catch (std::out_of_range& e) {
5199       {
5200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5201       };
5202     } catch (std::exception& e) {
5203       {
5204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5205       };
5206     } catch (Dali::DaliException e) {
5207       {
5208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5209       };
5210     } catch (...) {
5211       {
5212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5213       };
5214     }
5215   }
5216
5217 }
5218
5219
5220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5221   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5222   Dali::Vector2 *arg2 = 0 ;
5223   Dali::Vector2 *arg3 = 0 ;
5224
5225   arg1 = (Dali::Vector2 *)jarg1;
5226   arg2 = (Dali::Vector2 *)jarg2;
5227   if (!arg2) {
5228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5229     return ;
5230   }
5231   arg3 = (Dali::Vector2 *)jarg3;
5232   if (!arg3) {
5233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5234     return ;
5235   }
5236   {
5237     try {
5238       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5239     } catch (std::out_of_range& e) {
5240       {
5241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5242       };
5243     } catch (std::exception& e) {
5244       {
5245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (Dali::DaliException e) {
5248       {
5249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5250       };
5251     } catch (...) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5254       };
5255     }
5256   }
5257
5258 }
5259
5260
5261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5262   void * jresult ;
5263   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5264   float *result = 0 ;
5265
5266   arg1 = (Dali::Vector2 *)jarg1;
5267   {
5268     try {
5269       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5270     } catch (std::out_of_range& e) {
5271       {
5272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5273       };
5274     } catch (std::exception& e) {
5275       {
5276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5277       };
5278     } catch (Dali::DaliException e) {
5279       {
5280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5281       };
5282     } catch (...) {
5283       {
5284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5285       };
5286     }
5287   }
5288
5289   jresult = (void *)result;
5290   return jresult;
5291 }
5292
5293
5294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5295   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5296   float arg2 ;
5297
5298   arg1 = (Dali::Vector2 *)jarg1;
5299   arg2 = (float)jarg2;
5300   if (arg1) (arg1)->x = arg2;
5301 }
5302
5303
5304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5305   float jresult ;
5306   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5307   float result;
5308
5309   arg1 = (Dali::Vector2 *)jarg1;
5310   result = (float) ((arg1)->x);
5311   jresult = result;
5312   return jresult;
5313 }
5314
5315
5316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5317   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5318   float arg2 ;
5319
5320   arg1 = (Dali::Vector2 *)jarg1;
5321   arg2 = (float)jarg2;
5322   if (arg1) (arg1)->width = arg2;
5323 }
5324
5325
5326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5327   float jresult ;
5328   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5329   float result;
5330
5331   arg1 = (Dali::Vector2 *)jarg1;
5332   result = (float) ((arg1)->width);
5333   jresult = result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->y = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->y);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->height = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->height);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384
5385   arg1 = (Dali::Vector2 *)jarg1;
5386   {
5387     try {
5388       delete arg1;
5389     } catch (std::out_of_range& e) {
5390       {
5391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5392       };
5393     } catch (std::exception& e) {
5394       {
5395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5396       };
5397     } catch (Dali::DaliException e) {
5398       {
5399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5400       };
5401     } catch (...) {
5402       {
5403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5404       };
5405     }
5406   }
5407
5408 }
5409
5410
5411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5412   void * jresult ;
5413   Dali::Vector2 *arg1 = 0 ;
5414   Dali::Vector2 *arg2 = 0 ;
5415   Dali::Vector2 result;
5416
5417   arg1 = (Dali::Vector2 *)jarg1;
5418   if (!arg1) {
5419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5420     return 0;
5421   }
5422   arg2 = (Dali::Vector2 *)jarg2;
5423   if (!arg2) {
5424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5425     return 0;
5426   }
5427   {
5428     try {
5429       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5430     } catch (std::out_of_range& e) {
5431       {
5432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5433       };
5434     } catch (std::exception& e) {
5435       {
5436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (Dali::DaliException e) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448
5449   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5450   return jresult;
5451 }
5452
5453
5454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5455   void * jresult ;
5456   Dali::Vector2 *arg1 = 0 ;
5457   Dali::Vector2 *arg2 = 0 ;
5458   Dali::Vector2 result;
5459
5460   arg1 = (Dali::Vector2 *)jarg1;
5461   if (!arg1) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5463     return 0;
5464   }
5465   arg2 = (Dali::Vector2 *)jarg2;
5466   if (!arg2) {
5467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5468     return 0;
5469   }
5470   {
5471     try {
5472       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5473     } catch (std::out_of_range& e) {
5474       {
5475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (std::exception& e) {
5478       {
5479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (Dali::DaliException e) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5484       };
5485     } catch (...) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5488       };
5489     }
5490   }
5491
5492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5493   return jresult;
5494 }
5495
5496
5497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5498   void * jresult ;
5499   Dali::Vector2 *arg1 = 0 ;
5500   float *arg2 = 0 ;
5501   float *arg3 = 0 ;
5502   float temp2 ;
5503   float temp3 ;
5504   Dali::Vector2 result;
5505
5506   arg1 = (Dali::Vector2 *)jarg1;
5507   if (!arg1) {
5508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5509     return 0;
5510   }
5511   temp2 = (float)jarg2;
5512   arg2 = &temp2;
5513   temp3 = (float)jarg3;
5514   arg3 = &temp3;
5515   {
5516     try {
5517       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5543   void * jresult ;
5544   Dali::Vector3 *result = 0 ;
5545
5546   {
5547     try {
5548       result = (Dali::Vector3 *)new Dali::Vector3();
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (Dali::DaliException e) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5560       };
5561     } catch (...) {
5562       {
5563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5564       };
5565     }
5566   }
5567
5568   jresult = (void *)result;
5569   return jresult;
5570 }
5571
5572
5573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5574   void * jresult ;
5575   float arg1 ;
5576   float arg2 ;
5577   float arg3 ;
5578   Dali::Vector3 *result = 0 ;
5579
5580   arg1 = (float)jarg1;
5581   arg2 = (float)jarg2;
5582   arg3 = (float)jarg3;
5583   {
5584     try {
5585       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5586     } catch (std::out_of_range& e) {
5587       {
5588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5589       };
5590     } catch (std::exception& e) {
5591       {
5592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5593       };
5594     } catch (Dali::DaliException e) {
5595       {
5596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5597       };
5598     } catch (...) {
5599       {
5600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5601       };
5602     }
5603   }
5604
5605   jresult = (void *)result;
5606   return jresult;
5607 }
5608
5609
5610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5611   void * jresult ;
5612   float *arg1 = (float *) 0 ;
5613   Dali::Vector3 *result = 0 ;
5614
5615   arg1 = jarg1;
5616   {
5617     try {
5618       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5619     } catch (std::out_of_range& e) {
5620       {
5621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (std::exception& e) {
5624       {
5625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5626       };
5627     } catch (Dali::DaliException e) {
5628       {
5629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5630       };
5631     } catch (...) {
5632       {
5633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5634       };
5635     }
5636   }
5637
5638   jresult = (void *)result;
5639
5640
5641   return jresult;
5642 }
5643
5644
5645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5646   void * jresult ;
5647   Dali::Vector2 *arg1 = 0 ;
5648   Dali::Vector3 *result = 0 ;
5649
5650   arg1 = (Dali::Vector2 *)jarg1;
5651   if (!arg1) {
5652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5653     return 0;
5654   }
5655   {
5656     try {
5657       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5658     } catch (std::out_of_range& e) {
5659       {
5660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (std::exception& e) {
5663       {
5664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (Dali::DaliException e) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676
5677   jresult = (void *)result;
5678   return jresult;
5679 }
5680
5681
5682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5683   void * jresult ;
5684   Dali::Vector4 *arg1 = 0 ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   arg1 = (Dali::Vector4 *)jarg1;
5688   if (!arg1) {
5689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5690     return 0;
5691   }
5692   {
5693     try {
5694       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5695     } catch (std::out_of_range& e) {
5696       {
5697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5698       };
5699     } catch (std::exception& e) {
5700       {
5701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (Dali::DaliException e) {
5704       {
5705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5706       };
5707     } catch (...) {
5708       {
5709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5710       };
5711     }
5712   }
5713
5714   jresult = (void *)result;
5715   return jresult;
5716 }
5717
5718
5719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5720   void * jresult ;
5721   Dali::Vector3 *result = 0 ;
5722
5723   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5730   void * jresult ;
5731   Dali::Vector3 *result = 0 ;
5732
5733   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5734   jresult = (void *)result;
5735   return jresult;
5736 }
5737
5738
5739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5740   void * jresult ;
5741   Dali::Vector3 *result = 0 ;
5742
5743   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5744   jresult = (void *)result;
5745   return jresult;
5746 }
5747
5748
5749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5750   void * jresult ;
5751   Dali::Vector3 *result = 0 ;
5752
5753   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5754   jresult = (void *)result;
5755   return jresult;
5756 }
5757
5758
5759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5760   void * jresult ;
5761   Dali::Vector3 *result = 0 ;
5762
5763   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5764   jresult = (void *)result;
5765   return jresult;
5766 }
5767
5768
5769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5770   void * jresult ;
5771   Dali::Vector3 *result = 0 ;
5772
5773   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5774   jresult = (void *)result;
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5780   void * jresult ;
5781   Dali::Vector3 *result = 0 ;
5782
5783   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5784   jresult = (void *)result;
5785   return jresult;
5786 }
5787
5788
5789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5790   void * jresult ;
5791   Dali::Vector3 *result = 0 ;
5792
5793   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5794   jresult = (void *)result;
5795   return jresult;
5796 }
5797
5798
5799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5800   void * jresult ;
5801   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5802   float *arg2 = (float *) 0 ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   arg1 = (Dali::Vector3 *)jarg1;
5806   arg2 = jarg2;
5807   {
5808     try {
5809       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5810     } catch (std::out_of_range& e) {
5811       {
5812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (std::exception& e) {
5815       {
5816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5817       };
5818     } catch (Dali::DaliException e) {
5819       {
5820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5821       };
5822     } catch (...) {
5823       {
5824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5825       };
5826     }
5827   }
5828
5829   jresult = (void *)result;
5830
5831
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5837   void * jresult ;
5838   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5839   Dali::Vector2 *arg2 = 0 ;
5840   Dali::Vector3 *result = 0 ;
5841
5842   arg1 = (Dali::Vector3 *)jarg1;
5843   arg2 = (Dali::Vector2 *)jarg2;
5844   if (!arg2) {
5845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5846     return 0;
5847   }
5848   {
5849     try {
5850       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (Dali::DaliException e) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5862       };
5863     } catch (...) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5866       };
5867     }
5868   }
5869
5870   jresult = (void *)result;
5871   return jresult;
5872 }
5873
5874
5875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5876   void * jresult ;
5877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5878   Dali::Vector4 *arg2 = 0 ;
5879   Dali::Vector3 *result = 0 ;
5880
5881   arg1 = (Dali::Vector3 *)jarg1;
5882   arg2 = (Dali::Vector4 *)jarg2;
5883   if (!arg2) {
5884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5885     return 0;
5886   }
5887   {
5888     try {
5889       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5890     } catch (std::out_of_range& e) {
5891       {
5892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (std::exception& e) {
5895       {
5896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (Dali::DaliException e) {
5899       {
5900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5901       };
5902     } catch (...) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5905       };
5906     }
5907   }
5908
5909   jresult = (void *)result;
5910   return jresult;
5911 }
5912
5913
5914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5915   void * jresult ;
5916   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5917   Dali::Vector3 *arg2 = 0 ;
5918   Dali::Vector3 result;
5919
5920   arg1 = (Dali::Vector3 *)jarg1;
5921   arg2 = (Dali::Vector3 *)jarg2;
5922   if (!arg2) {
5923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5924     return 0;
5925   }
5926   {
5927     try {
5928       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (Dali::DaliException e) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947
5948   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5949   return jresult;
5950 }
5951
5952
5953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5954   void * jresult ;
5955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5956   Dali::Vector3 *arg2 = 0 ;
5957   Dali::Vector3 *result = 0 ;
5958
5959   arg1 = (Dali::Vector3 *)jarg1;
5960   arg2 = (Dali::Vector3 *)jarg2;
5961   if (!arg2) {
5962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5963     return 0;
5964   }
5965   {
5966     try {
5967       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5968     } catch (std::out_of_range& e) {
5969       {
5970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (std::exception& e) {
5973       {
5974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5975       };
5976     } catch (Dali::DaliException e) {
5977       {
5978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5979       };
5980     } catch (...) {
5981       {
5982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5983       };
5984     }
5985   }
5986
5987   jresult = (void *)result;
5988   return jresult;
5989 }
5990
5991
5992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5993   void * jresult ;
5994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5995   Dali::Vector3 *arg2 = 0 ;
5996   Dali::Vector3 result;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   arg2 = (Dali::Vector3 *)jarg2;
6000   if (!arg2) {
6001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6002     return 0;
6003   }
6004   {
6005     try {
6006       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6007     } catch (std::out_of_range& e) {
6008       {
6009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6010       };
6011     } catch (std::exception& e) {
6012       {
6013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (Dali::DaliException e) {
6016       {
6017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6018       };
6019     } catch (...) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6022       };
6023     }
6024   }
6025
6026   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6027   return jresult;
6028 }
6029
6030
6031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6032   void * jresult ;
6033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6034   Dali::Vector3 *arg2 = 0 ;
6035   Dali::Vector3 *result = 0 ;
6036
6037   arg1 = (Dali::Vector3 *)jarg1;
6038   arg2 = (Dali::Vector3 *)jarg2;
6039   if (!arg2) {
6040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6041     return 0;
6042   }
6043   {
6044     try {
6045       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6046     } catch (std::out_of_range& e) {
6047       {
6048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (std::exception& e) {
6051       {
6052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (Dali::DaliException e) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6057       };
6058     } catch (...) {
6059       {
6060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6061       };
6062     }
6063   }
6064
6065   jresult = (void *)result;
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6071   void * jresult ;
6072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6073   Dali::Vector3 *arg2 = 0 ;
6074   Dali::Vector3 result;
6075
6076   arg1 = (Dali::Vector3 *)jarg1;
6077   arg2 = (Dali::Vector3 *)jarg2;
6078   if (!arg2) {
6079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6080     return 0;
6081   }
6082   {
6083     try {
6084       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6085     } catch (std::out_of_range& e) {
6086       {
6087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (std::exception& e) {
6090       {
6091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (Dali::DaliException e) {
6094       {
6095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6096       };
6097     } catch (...) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6100       };
6101     }
6102   }
6103
6104   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6105   return jresult;
6106 }
6107
6108
6109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6110   void * jresult ;
6111   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6112   float arg2 ;
6113   Dali::Vector3 result;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   arg2 = (float)jarg2;
6117   {
6118     try {
6119       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6120     } catch (std::out_of_range& e) {
6121       {
6122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (std::exception& e) {
6125       {
6126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (Dali::DaliException e) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6131       };
6132     } catch (...) {
6133       {
6134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6135       };
6136     }
6137   }
6138
6139   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6140   return jresult;
6141 }
6142
6143
6144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6145   void * jresult ;
6146   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6147   Dali::Vector3 *arg2 = 0 ;
6148   Dali::Vector3 *result = 0 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   arg2 = (Dali::Vector3 *)jarg2;
6152   if (!arg2) {
6153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6154     return 0;
6155   }
6156   {
6157     try {
6158       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6159     } catch (std::out_of_range& e) {
6160       {
6161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6162       };
6163     } catch (std::exception& e) {
6164       {
6165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (Dali::DaliException e) {
6168       {
6169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6170       };
6171     } catch (...) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6174       };
6175     }
6176   }
6177
6178   jresult = (void *)result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   float arg2 ;
6187   Dali::Vector3 *result = 0 ;
6188
6189   arg1 = (Dali::Vector3 *)jarg1;
6190   arg2 = (float)jarg2;
6191   {
6192     try {
6193       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6194     } catch (std::out_of_range& e) {
6195       {
6196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (std::exception& e) {
6199       {
6200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6201       };
6202     } catch (Dali::DaliException e) {
6203       {
6204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6205       };
6206     } catch (...) {
6207       {
6208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6209       };
6210     }
6211   }
6212
6213   jresult = (void *)result;
6214   return jresult;
6215 }
6216
6217
6218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6219   void * jresult ;
6220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6221   Dali::Quaternion *arg2 = 0 ;
6222   Dali::Vector3 *result = 0 ;
6223
6224   arg1 = (Dali::Vector3 *)jarg1;
6225   arg2 = (Dali::Quaternion *)jarg2;
6226   if (!arg2) {
6227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6228     return 0;
6229   }
6230   {
6231     try {
6232       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6233     } catch (std::out_of_range& e) {
6234       {
6235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6236       };
6237     } catch (std::exception& e) {
6238       {
6239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6240       };
6241     } catch (Dali::DaliException e) {
6242       {
6243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6244       };
6245     } catch (...) {
6246       {
6247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6248       };
6249     }
6250   }
6251
6252   jresult = (void *)result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6258   void * jresult ;
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   Dali::Vector3 *arg2 = 0 ;
6261   Dali::Vector3 result;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (Dali::Vector3 *)jarg2;
6265   if (!arg2) {
6266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6267     return 0;
6268   }
6269   {
6270     try {
6271       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6272     } catch (std::out_of_range& e) {
6273       {
6274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6275       };
6276     } catch (std::exception& e) {
6277       {
6278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6279       };
6280     } catch (Dali::DaliException e) {
6281       {
6282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6283       };
6284     } catch (...) {
6285       {
6286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6287       };
6288     }
6289   }
6290
6291   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6292   return jresult;
6293 }
6294
6295
6296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6297   void * jresult ;
6298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6299   float arg2 ;
6300   Dali::Vector3 result;
6301
6302   arg1 = (Dali::Vector3 *)jarg1;
6303   arg2 = (float)jarg2;
6304   {
6305     try {
6306       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6307     } catch (std::out_of_range& e) {
6308       {
6309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6310       };
6311     } catch (std::exception& e) {
6312       {
6313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6314       };
6315     } catch (Dali::DaliException e) {
6316       {
6317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6318       };
6319     } catch (...) {
6320       {
6321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6322       };
6323     }
6324   }
6325
6326   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6327   return jresult;
6328 }
6329
6330
6331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6332   void * jresult ;
6333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6334   Dali::Vector3 *arg2 = 0 ;
6335   Dali::Vector3 *result = 0 ;
6336
6337   arg1 = (Dali::Vector3 *)jarg1;
6338   arg2 = (Dali::Vector3 *)jarg2;
6339   if (!arg2) {
6340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6341     return 0;
6342   }
6343   {
6344     try {
6345       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6346     } catch (std::out_of_range& e) {
6347       {
6348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6349       };
6350     } catch (std::exception& e) {
6351       {
6352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6353       };
6354     } catch (Dali::DaliException e) {
6355       {
6356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6357       };
6358     } catch (...) {
6359       {
6360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6361       };
6362     }
6363   }
6364
6365   jresult = (void *)result;
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6371   void * jresult ;
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   float arg2 ;
6374   Dali::Vector3 *result = 0 ;
6375
6376   arg1 = (Dali::Vector3 *)jarg1;
6377   arg2 = (float)jarg2;
6378   {
6379     try {
6380       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6381     } catch (std::out_of_range& e) {
6382       {
6383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (std::exception& e) {
6386       {
6387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6388       };
6389     } catch (Dali::DaliException e) {
6390       {
6391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6392       };
6393     } catch (...) {
6394       {
6395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6396       };
6397     }
6398   }
6399
6400   jresult = (void *)result;
6401   return jresult;
6402 }
6403
6404
6405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6406   void * jresult ;
6407   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6408   Dali::Vector3 result;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   {
6412     try {
6413       result = ((Dali::Vector3 const *)arg1)->operator -();
6414     } catch (std::out_of_range& e) {
6415       {
6416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6417       };
6418     } catch (std::exception& e) {
6419       {
6420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6421       };
6422     } catch (Dali::DaliException e) {
6423       {
6424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6425       };
6426     } catch (...) {
6427       {
6428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6429       };
6430     }
6431   }
6432
6433   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6434   return jresult;
6435 }
6436
6437
6438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6439   unsigned int jresult ;
6440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6441   Dali::Vector3 *arg2 = 0 ;
6442   bool result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   arg2 = (Dali::Vector3 *)jarg2;
6446   if (!arg2) {
6447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6448     return 0;
6449   }
6450   {
6451     try {
6452       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6453     } catch (std::out_of_range& e) {
6454       {
6455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6456       };
6457     } catch (std::exception& e) {
6458       {
6459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (Dali::DaliException e) {
6462       {
6463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471
6472   jresult = result;
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6478   unsigned int jresult ;
6479   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6480   Dali::Vector3 *arg2 = 0 ;
6481   bool result;
6482
6483   arg1 = (Dali::Vector3 *)jarg1;
6484   arg2 = (Dali::Vector3 *)jarg2;
6485   if (!arg2) {
6486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6487     return 0;
6488   }
6489   {
6490     try {
6491       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6492     } catch (std::out_of_range& e) {
6493       {
6494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6495       };
6496     } catch (std::exception& e) {
6497       {
6498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6499       };
6500     } catch (Dali::DaliException e) {
6501       {
6502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6503       };
6504     } catch (...) {
6505       {
6506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6507       };
6508     }
6509   }
6510
6511   jresult = result;
6512   return jresult;
6513 }
6514
6515
6516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6517   float jresult ;
6518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6519   unsigned int arg2 ;
6520   float *result = 0 ;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   arg2 = (unsigned int)jarg2;
6524   {
6525     try {
6526       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6527     } catch (std::out_of_range& e) {
6528       {
6529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6530       };
6531     } catch (std::exception& e) {
6532       {
6533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (Dali::DaliException e) {
6536       {
6537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6538       };
6539     } catch (...) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6542       };
6543     }
6544   }
6545
6546   jresult = *result;
6547   return jresult;
6548 }
6549
6550
6551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6552   float jresult ;
6553   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6554   Dali::Vector3 *arg2 = 0 ;
6555   float result;
6556
6557   arg1 = (Dali::Vector3 *)jarg1;
6558   arg2 = (Dali::Vector3 *)jarg2;
6559   if (!arg2) {
6560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6561     return 0;
6562   }
6563   {
6564     try {
6565       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6566     } catch (std::out_of_range& e) {
6567       {
6568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (std::exception& e) {
6571       {
6572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6573       };
6574     } catch (Dali::DaliException e) {
6575       {
6576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6577       };
6578     } catch (...) {
6579       {
6580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6581       };
6582     }
6583   }
6584
6585   jresult = result;
6586   return jresult;
6587 }
6588
6589
6590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6591   void * jresult ;
6592   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6593   Dali::Vector3 *arg2 = 0 ;
6594   Dali::Vector3 result;
6595
6596   arg1 = (Dali::Vector3 *)jarg1;
6597   arg2 = (Dali::Vector3 *)jarg2;
6598   if (!arg2) {
6599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6600     return 0;
6601   }
6602   {
6603     try {
6604       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6605     } catch (std::out_of_range& e) {
6606       {
6607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6608       };
6609     } catch (std::exception& e) {
6610       {
6611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (Dali::DaliException e) {
6614       {
6615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6616       };
6617     } catch (...) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6620       };
6621     }
6622   }
6623
6624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6630   float jresult ;
6631   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6632   float result;
6633
6634   arg1 = (Dali::Vector3 *)jarg1;
6635   {
6636     try {
6637       result = (float)((Dali::Vector3 const *)arg1)->Length();
6638     } catch (std::out_of_range& e) {
6639       {
6640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6641       };
6642     } catch (std::exception& e) {
6643       {
6644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6645       };
6646     } catch (Dali::DaliException e) {
6647       {
6648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6649       };
6650     } catch (...) {
6651       {
6652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6653       };
6654     }
6655   }
6656
6657   jresult = result;
6658   return jresult;
6659 }
6660
6661
6662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6663   float jresult ;
6664   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6665   float result;
6666
6667   arg1 = (Dali::Vector3 *)jarg1;
6668   {
6669     try {
6670       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6671     } catch (std::out_of_range& e) {
6672       {
6673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6674       };
6675     } catch (std::exception& e) {
6676       {
6677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6678       };
6679     } catch (Dali::DaliException e) {
6680       {
6681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6682       };
6683     } catch (...) {
6684       {
6685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6686       };
6687     }
6688   }
6689
6690   jresult = result;
6691   return jresult;
6692 }
6693
6694
6695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6696   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6697
6698   arg1 = (Dali::Vector3 *)jarg1;
6699   {
6700     try {
6701       (arg1)->Normalize();
6702     } catch (std::out_of_range& e) {
6703       {
6704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6705       };
6706     } catch (std::exception& e) {
6707       {
6708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6709       };
6710     } catch (Dali::DaliException e) {
6711       {
6712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6713       };
6714     } catch (...) {
6715       {
6716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6717       };
6718     }
6719   }
6720
6721 }
6722
6723
6724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6725   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6726   Dali::Vector3 *arg2 = 0 ;
6727   Dali::Vector3 *arg3 = 0 ;
6728
6729   arg1 = (Dali::Vector3 *)jarg1;
6730   arg2 = (Dali::Vector3 *)jarg2;
6731   if (!arg2) {
6732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6733     return ;
6734   }
6735   arg3 = (Dali::Vector3 *)jarg3;
6736   if (!arg3) {
6737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6738     return ;
6739   }
6740   {
6741     try {
6742       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6743     } catch (std::out_of_range& e) {
6744       {
6745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6746       };
6747     } catch (std::exception& e) {
6748       {
6749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (Dali::DaliException e) {
6752       {
6753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6758       };
6759     }
6760   }
6761
6762 }
6763
6764
6765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6766   void * jresult ;
6767   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6768   float *result = 0 ;
6769
6770   arg1 = (Dali::Vector3 *)jarg1;
6771   {
6772     try {
6773       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6774     } catch (std::out_of_range& e) {
6775       {
6776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6777       };
6778     } catch (std::exception& e) {
6779       {
6780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6781       };
6782     } catch (Dali::DaliException e) {
6783       {
6784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6785       };
6786     } catch (...) {
6787       {
6788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6789       };
6790     }
6791   }
6792
6793   jresult = (void *)result;
6794   return jresult;
6795 }
6796
6797
6798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6799   void * jresult ;
6800   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6801   Dali::Vector2 *result = 0 ;
6802
6803   arg1 = (Dali::Vector3 *)jarg1;
6804   {
6805     try {
6806       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6807     } catch (std::out_of_range& e) {
6808       {
6809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6810       };
6811     } catch (std::exception& e) {
6812       {
6813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6814       };
6815     } catch (Dali::DaliException e) {
6816       {
6817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6818       };
6819     } catch (...) {
6820       {
6821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6822       };
6823     }
6824   }
6825
6826   jresult = (void *)result;
6827   return jresult;
6828 }
6829
6830
6831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6832   void * jresult ;
6833   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6834   Dali::Vector2 *result = 0 ;
6835
6836   arg1 = (Dali::Vector3 *)jarg1;
6837   {
6838     try {
6839       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6840     } catch (std::out_of_range& e) {
6841       {
6842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6843       };
6844     } catch (std::exception& e) {
6845       {
6846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6847       };
6848     } catch (Dali::DaliException e) {
6849       {
6850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6851       };
6852     } catch (...) {
6853       {
6854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6855       };
6856     }
6857   }
6858
6859   jresult = (void *)result;
6860   return jresult;
6861 }
6862
6863
6864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6865   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6866   float arg2 ;
6867
6868   arg1 = (Dali::Vector3 *)jarg1;
6869   arg2 = (float)jarg2;
6870   if (arg1) (arg1)->x = arg2;
6871 }
6872
6873
6874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6875   float jresult ;
6876   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6877   float result;
6878
6879   arg1 = (Dali::Vector3 *)jarg1;
6880   result = (float) ((arg1)->x);
6881   jresult = result;
6882   return jresult;
6883 }
6884
6885
6886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6887   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6888   float arg2 ;
6889
6890   arg1 = (Dali::Vector3 *)jarg1;
6891   arg2 = (float)jarg2;
6892   if (arg1) (arg1)->width = arg2;
6893 }
6894
6895
6896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6897   float jresult ;
6898   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6899   float result;
6900
6901   arg1 = (Dali::Vector3 *)jarg1;
6902   result = (float) ((arg1)->width);
6903   jresult = result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->r = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->r);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->y = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->y);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->height = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->height);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->g = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->g);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->z = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->z);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->depth = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->depth);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->b = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->b);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064
7065   arg1 = (Dali::Vector3 *)jarg1;
7066   {
7067     try {
7068       delete arg1;
7069     } catch (std::out_of_range& e) {
7070       {
7071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7072       };
7073     } catch (std::exception& e) {
7074       {
7075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7076       };
7077     } catch (Dali::DaliException e) {
7078       {
7079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7080       };
7081     } catch (...) {
7082       {
7083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7084       };
7085     }
7086   }
7087
7088 }
7089
7090
7091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7092   void * jresult ;
7093   Dali::Vector3 *arg1 = 0 ;
7094   Dali::Vector3 *arg2 = 0 ;
7095   Dali::Vector3 result;
7096
7097   arg1 = (Dali::Vector3 *)jarg1;
7098   if (!arg1) {
7099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7100     return 0;
7101   }
7102   arg2 = (Dali::Vector3 *)jarg2;
7103   if (!arg2) {
7104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7105     return 0;
7106   }
7107   {
7108     try {
7109       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7110     } catch (std::out_of_range& e) {
7111       {
7112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7113       };
7114     } catch (std::exception& e) {
7115       {
7116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7117       };
7118     } catch (Dali::DaliException e) {
7119       {
7120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7121       };
7122     } catch (...) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7125       };
7126     }
7127   }
7128
7129   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7135   void * jresult ;
7136   Dali::Vector3 *arg1 = 0 ;
7137   Dali::Vector3 *arg2 = 0 ;
7138   Dali::Vector3 result;
7139
7140   arg1 = (Dali::Vector3 *)jarg1;
7141   if (!arg1) {
7142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7143     return 0;
7144   }
7145   arg2 = (Dali::Vector3 *)jarg2;
7146   if (!arg2) {
7147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7148     return 0;
7149   }
7150   {
7151     try {
7152       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7153     } catch (std::out_of_range& e) {
7154       {
7155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (std::exception& e) {
7158       {
7159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (Dali::DaliException e) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7164       };
7165     } catch (...) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7168       };
7169     }
7170   }
7171
7172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7173   return jresult;
7174 }
7175
7176
7177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7178   void * jresult ;
7179   Dali::Vector3 *arg1 = 0 ;
7180   float *arg2 = 0 ;
7181   float *arg3 = 0 ;
7182   float temp2 ;
7183   float temp3 ;
7184   Dali::Vector3 result;
7185
7186   arg1 = (Dali::Vector3 *)jarg1;
7187   if (!arg1) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7189     return 0;
7190   }
7191   temp2 = (float)jarg2;
7192   arg2 = &temp2;
7193   temp3 = (float)jarg3;
7194   arg3 = &temp3;
7195   {
7196     try {
7197       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7223   void * jresult ;
7224   Dali::Vector4 *result = 0 ;
7225
7226   {
7227     try {
7228       result = (Dali::Vector4 *)new Dali::Vector4();
7229     } catch (std::out_of_range& e) {
7230       {
7231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7232       };
7233     } catch (std::exception& e) {
7234       {
7235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (Dali::DaliException e) {
7238       {
7239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247
7248   jresult = (void *)result;
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7254   void * jresult ;
7255   float arg1 ;
7256   float arg2 ;
7257   float arg3 ;
7258   float arg4 ;
7259   Dali::Vector4 *result = 0 ;
7260
7261   arg1 = (float)jarg1;
7262   arg2 = (float)jarg2;
7263   arg3 = (float)jarg3;
7264   arg4 = (float)jarg4;
7265   {
7266     try {
7267       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7268     } catch (std::out_of_range& e) {
7269       {
7270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (std::exception& e) {
7273       {
7274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (Dali::DaliException e) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7279       };
7280     } catch (...) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7283       };
7284     }
7285   }
7286
7287   jresult = (void *)result;
7288   return jresult;
7289 }
7290
7291
7292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7293   void * jresult ;
7294   float *arg1 = (float *) 0 ;
7295   Dali::Vector4 *result = 0 ;
7296
7297   arg1 = jarg1;
7298   {
7299     try {
7300       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7301     } catch (std::out_of_range& e) {
7302       {
7303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (std::exception& e) {
7306       {
7307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7308       };
7309     } catch (Dali::DaliException e) {
7310       {
7311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7312       };
7313     } catch (...) {
7314       {
7315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7316       };
7317     }
7318   }
7319
7320   jresult = (void *)result;
7321
7322
7323   return jresult;
7324 }
7325
7326
7327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7328   void * jresult ;
7329   Dali::Vector2 *arg1 = 0 ;
7330   Dali::Vector4 *result = 0 ;
7331
7332   arg1 = (Dali::Vector2 *)jarg1;
7333   if (!arg1) {
7334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7335     return 0;
7336   }
7337   {
7338     try {
7339       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7340     } catch (std::out_of_range& e) {
7341       {
7342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7343       };
7344     } catch (std::exception& e) {
7345       {
7346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7347       };
7348     } catch (Dali::DaliException e) {
7349       {
7350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7351       };
7352     } catch (...) {
7353       {
7354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7355       };
7356     }
7357   }
7358
7359   jresult = (void *)result;
7360   return jresult;
7361 }
7362
7363
7364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7365   void * jresult ;
7366   Dali::Vector3 *arg1 = 0 ;
7367   Dali::Vector4 *result = 0 ;
7368
7369   arg1 = (Dali::Vector3 *)jarg1;
7370   if (!arg1) {
7371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7372     return 0;
7373   }
7374   {
7375     try {
7376       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7377     } catch (std::out_of_range& e) {
7378       {
7379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7380       };
7381     } catch (std::exception& e) {
7382       {
7383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (Dali::DaliException e) {
7386       {
7387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7388       };
7389     } catch (...) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7392       };
7393     }
7394   }
7395
7396   jresult = (void *)result;
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7402   void * jresult ;
7403   Dali::Vector4 *result = 0 ;
7404
7405   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7412   void * jresult ;
7413   Dali::Vector4 *result = 0 ;
7414
7415   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7416   jresult = (void *)result;
7417   return jresult;
7418 }
7419
7420
7421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7422   void * jresult ;
7423   Dali::Vector4 *result = 0 ;
7424
7425   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7426   jresult = (void *)result;
7427   return jresult;
7428 }
7429
7430
7431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7432   void * jresult ;
7433   Dali::Vector4 *result = 0 ;
7434
7435   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7436   jresult = (void *)result;
7437   return jresult;
7438 }
7439
7440
7441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7442   void * jresult ;
7443   Dali::Vector4 *result = 0 ;
7444
7445   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7446   jresult = (void *)result;
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7452   void * jresult ;
7453   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7454   float *arg2 = (float *) 0 ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   arg1 = (Dali::Vector4 *)jarg1;
7458   arg2 = jarg2;
7459   {
7460     try {
7461       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7462     } catch (std::out_of_range& e) {
7463       {
7464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (std::exception& e) {
7467       {
7468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7469       };
7470     } catch (Dali::DaliException e) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7473       };
7474     } catch (...) {
7475       {
7476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7477       };
7478     }
7479   }
7480
7481   jresult = (void *)result;
7482
7483
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7489   void * jresult ;
7490   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7491   Dali::Vector2 *arg2 = 0 ;
7492   Dali::Vector4 *result = 0 ;
7493
7494   arg1 = (Dali::Vector4 *)jarg1;
7495   arg2 = (Dali::Vector2 *)jarg2;
7496   if (!arg2) {
7497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7498     return 0;
7499   }
7500   {
7501     try {
7502       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7503     } catch (std::out_of_range& e) {
7504       {
7505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7506       };
7507     } catch (std::exception& e) {
7508       {
7509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (Dali::DaliException e) {
7512       {
7513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7514       };
7515     } catch (...) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7518       };
7519     }
7520   }
7521
7522   jresult = (void *)result;
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7528   void * jresult ;
7529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7530   Dali::Vector3 *arg2 = 0 ;
7531   Dali::Vector4 *result = 0 ;
7532
7533   arg1 = (Dali::Vector4 *)jarg1;
7534   arg2 = (Dali::Vector3 *)jarg2;
7535   if (!arg2) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7542     } catch (std::out_of_range& e) {
7543       {
7544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (std::exception& e) {
7547       {
7548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (Dali::DaliException e) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7553       };
7554     } catch (...) {
7555       {
7556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7557       };
7558     }
7559   }
7560
7561   jresult = (void *)result;
7562   return jresult;
7563 }
7564
7565
7566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7567   void * jresult ;
7568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7569   Dali::Vector4 *arg2 = 0 ;
7570   Dali::Vector4 result;
7571
7572   arg1 = (Dali::Vector4 *)jarg1;
7573   arg2 = (Dali::Vector4 *)jarg2;
7574   if (!arg2) {
7575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7576     return 0;
7577   }
7578   {
7579     try {
7580       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7581     } catch (std::out_of_range& e) {
7582       {
7583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (std::exception& e) {
7586       {
7587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7588       };
7589     } catch (Dali::DaliException e) {
7590       {
7591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7592       };
7593     } catch (...) {
7594       {
7595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7596       };
7597     }
7598   }
7599
7600   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7601   return jresult;
7602 }
7603
7604
7605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7606   void * jresult ;
7607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7608   Dali::Vector4 *arg2 = 0 ;
7609   Dali::Vector4 *result = 0 ;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   arg2 = (Dali::Vector4 *)jarg2;
7613   if (!arg2) {
7614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7615     return 0;
7616   }
7617   {
7618     try {
7619       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7620     } catch (std::out_of_range& e) {
7621       {
7622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7623       };
7624     } catch (std::exception& e) {
7625       {
7626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7627       };
7628     } catch (Dali::DaliException e) {
7629       {
7630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7631       };
7632     } catch (...) {
7633       {
7634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7635       };
7636     }
7637   }
7638
7639   jresult = (void *)result;
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7645   void * jresult ;
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   Dali::Vector4 *arg2 = 0 ;
7648   Dali::Vector4 result;
7649
7650   arg1 = (Dali::Vector4 *)jarg1;
7651   arg2 = (Dali::Vector4 *)jarg2;
7652   if (!arg2) {
7653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7654     return 0;
7655   }
7656   {
7657     try {
7658       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7659     } catch (std::out_of_range& e) {
7660       {
7661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (std::exception& e) {
7664       {
7665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (Dali::DaliException e) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7670       };
7671     } catch (...) {
7672       {
7673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7674       };
7675     }
7676   }
7677
7678   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7679   return jresult;
7680 }
7681
7682
7683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7684   void * jresult ;
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   Dali::Vector4 *arg2 = 0 ;
7687   Dali::Vector4 *result = 0 ;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (Dali::Vector4 *)jarg2;
7691   if (!arg2) {
7692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7693     return 0;
7694   }
7695   {
7696     try {
7697       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7698     } catch (std::out_of_range& e) {
7699       {
7700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7701       };
7702     } catch (std::exception& e) {
7703       {
7704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7705       };
7706     } catch (Dali::DaliException e) {
7707       {
7708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7709       };
7710     } catch (...) {
7711       {
7712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7713       };
7714     }
7715   }
7716
7717   jresult = (void *)result;
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7723   void * jresult ;
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   Dali::Vector4 *arg2 = 0 ;
7726   Dali::Vector4 result;
7727
7728   arg1 = (Dali::Vector4 *)jarg1;
7729   arg2 = (Dali::Vector4 *)jarg2;
7730   if (!arg2) {
7731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7732     return 0;
7733   }
7734   {
7735     try {
7736       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7737     } catch (std::out_of_range& e) {
7738       {
7739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7740       };
7741     } catch (std::exception& e) {
7742       {
7743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7744       };
7745     } catch (Dali::DaliException e) {
7746       {
7747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7748       };
7749     } catch (...) {
7750       {
7751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7752       };
7753     }
7754   }
7755
7756   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7757   return jresult;
7758 }
7759
7760
7761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7762   void * jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float arg2 ;
7765   Dali::Vector4 result;
7766
7767   arg1 = (Dali::Vector4 *)jarg1;
7768   arg2 = (float)jarg2;
7769   {
7770     try {
7771       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7772     } catch (std::out_of_range& e) {
7773       {
7774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7775       };
7776     } catch (std::exception& e) {
7777       {
7778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7779       };
7780     } catch (Dali::DaliException e) {
7781       {
7782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7783       };
7784     } catch (...) {
7785       {
7786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7787       };
7788     }
7789   }
7790
7791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7792   return jresult;
7793 }
7794
7795
7796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7797   void * jresult ;
7798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7799   Dali::Vector4 *arg2 = 0 ;
7800   Dali::Vector4 *result = 0 ;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   arg2 = (Dali::Vector4 *)jarg2;
7804   if (!arg2) {
7805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7806     return 0;
7807   }
7808   {
7809     try {
7810       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7811     } catch (std::out_of_range& e) {
7812       {
7813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7814       };
7815     } catch (std::exception& e) {
7816       {
7817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7818       };
7819     } catch (Dali::DaliException e) {
7820       {
7821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7822       };
7823     } catch (...) {
7824       {
7825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7826       };
7827     }
7828   }
7829
7830   jresult = (void *)result;
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7836   void * jresult ;
7837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7838   float arg2 ;
7839   Dali::Vector4 *result = 0 ;
7840
7841   arg1 = (Dali::Vector4 *)jarg1;
7842   arg2 = (float)jarg2;
7843   {
7844     try {
7845       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7846     } catch (std::out_of_range& e) {
7847       {
7848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (std::exception& e) {
7851       {
7852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7853       };
7854     } catch (Dali::DaliException e) {
7855       {
7856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7857       };
7858     } catch (...) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7861       };
7862     }
7863   }
7864
7865   jresult = (void *)result;
7866   return jresult;
7867 }
7868
7869
7870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7871   void * jresult ;
7872   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7873   Dali::Vector4 *arg2 = 0 ;
7874   Dali::Vector4 result;
7875
7876   arg1 = (Dali::Vector4 *)jarg1;
7877   arg2 = (Dali::Vector4 *)jarg2;
7878   if (!arg2) {
7879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7880     return 0;
7881   }
7882   {
7883     try {
7884       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (Dali::DaliException e) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7896       };
7897     } catch (...) {
7898       {
7899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7900       };
7901     }
7902   }
7903
7904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7905   return jresult;
7906 }
7907
7908
7909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7910   void * jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   float arg2 ;
7913   Dali::Vector4 result;
7914
7915   arg1 = (Dali::Vector4 *)jarg1;
7916   arg2 = (float)jarg2;
7917   {
7918     try {
7919       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7920     } catch (std::out_of_range& e) {
7921       {
7922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7923       };
7924     } catch (std::exception& e) {
7925       {
7926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (Dali::DaliException e) {
7929       {
7930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7931       };
7932     } catch (...) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7935       };
7936     }
7937   }
7938
7939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7940   return jresult;
7941 }
7942
7943
7944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7945   void * jresult ;
7946   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7947   Dali::Vector4 *arg2 = 0 ;
7948   Dali::Vector4 *result = 0 ;
7949
7950   arg1 = (Dali::Vector4 *)jarg1;
7951   arg2 = (Dali::Vector4 *)jarg2;
7952   if (!arg2) {
7953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7954     return 0;
7955   }
7956   {
7957     try {
7958       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7959     } catch (std::out_of_range& e) {
7960       {
7961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7962       };
7963     } catch (std::exception& e) {
7964       {
7965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (Dali::DaliException e) {
7968       {
7969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977
7978   jresult = (void *)result;
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7984   void * jresult ;
7985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7986   float arg2 ;
7987   Dali::Vector4 *result = 0 ;
7988
7989   arg1 = (Dali::Vector4 *)jarg1;
7990   arg2 = (float)jarg2;
7991   {
7992     try {
7993       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7994     } catch (std::out_of_range& e) {
7995       {
7996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (std::exception& e) {
7999       {
8000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8001       };
8002     } catch (Dali::DaliException e) {
8003       {
8004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8005       };
8006     } catch (...) {
8007       {
8008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8009       };
8010     }
8011   }
8012
8013   jresult = (void *)result;
8014   return jresult;
8015 }
8016
8017
8018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8019   void * jresult ;
8020   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8021   Dali::Vector4 result;
8022
8023   arg1 = (Dali::Vector4 *)jarg1;
8024   {
8025     try {
8026       result = ((Dali::Vector4 const *)arg1)->operator -();
8027     } catch (std::out_of_range& e) {
8028       {
8029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8030       };
8031     } catch (std::exception& e) {
8032       {
8033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8034       };
8035     } catch (Dali::DaliException e) {
8036       {
8037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8038       };
8039     } catch (...) {
8040       {
8041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8042       };
8043     }
8044   }
8045
8046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8047   return jresult;
8048 }
8049
8050
8051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8052   unsigned int jresult ;
8053   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8054   Dali::Vector4 *arg2 = 0 ;
8055   bool result;
8056
8057   arg1 = (Dali::Vector4 *)jarg1;
8058   arg2 = (Dali::Vector4 *)jarg2;
8059   if (!arg2) {
8060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8061     return 0;
8062   }
8063   {
8064     try {
8065       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8066     } catch (std::out_of_range& e) {
8067       {
8068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (std::exception& e) {
8071       {
8072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (Dali::DaliException e) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084
8085   jresult = result;
8086   return jresult;
8087 }
8088
8089
8090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8091   unsigned int jresult ;
8092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8093   Dali::Vector4 *arg2 = 0 ;
8094   bool result;
8095
8096   arg1 = (Dali::Vector4 *)jarg1;
8097   arg2 = (Dali::Vector4 *)jarg2;
8098   if (!arg2) {
8099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8100     return 0;
8101   }
8102   {
8103     try {
8104       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (Dali::DaliException e) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8116       };
8117     } catch (...) {
8118       {
8119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8120       };
8121     }
8122   }
8123
8124   jresult = result;
8125   return jresult;
8126 }
8127
8128
8129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8130   float jresult ;
8131   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8132   unsigned int arg2 ;
8133   float *result = 0 ;
8134
8135   arg1 = (Dali::Vector4 *)jarg1;
8136   arg2 = (unsigned int)jarg2;
8137   {
8138     try {
8139       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8140     } catch (std::out_of_range& e) {
8141       {
8142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8143       };
8144     } catch (std::exception& e) {
8145       {
8146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8147       };
8148     } catch (Dali::DaliException e) {
8149       {
8150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8151       };
8152     } catch (...) {
8153       {
8154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8155       };
8156     }
8157   }
8158
8159   jresult = *result;
8160   return jresult;
8161 }
8162
8163
8164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8165   float jresult ;
8166   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8167   Dali::Vector3 *arg2 = 0 ;
8168   float result;
8169
8170   arg1 = (Dali::Vector4 *)jarg1;
8171   arg2 = (Dali::Vector3 *)jarg2;
8172   if (!arg2) {
8173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8174     return 0;
8175   }
8176   {
8177     try {
8178       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8179     } catch (std::out_of_range& e) {
8180       {
8181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8182       };
8183     } catch (std::exception& e) {
8184       {
8185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (Dali::DaliException e) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197
8198   jresult = result;
8199   return jresult;
8200 }
8201
8202
8203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8204   float jresult ;
8205   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8206   Dali::Vector4 *arg2 = 0 ;
8207   float result;
8208
8209   arg1 = (Dali::Vector4 *)jarg1;
8210   arg2 = (Dali::Vector4 *)jarg2;
8211   if (!arg2) {
8212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8213     return 0;
8214   }
8215   {
8216     try {
8217       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8218     } catch (std::out_of_range& e) {
8219       {
8220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (std::exception& e) {
8223       {
8224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (Dali::DaliException e) {
8227       {
8228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8229       };
8230     } catch (...) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8233       };
8234     }
8235   }
8236
8237   jresult = result;
8238   return jresult;
8239 }
8240
8241
8242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8243   float jresult ;
8244   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8245   Dali::Vector4 *arg2 = 0 ;
8246   float result;
8247
8248   arg1 = (Dali::Vector4 *)jarg1;
8249   arg2 = (Dali::Vector4 *)jarg2;
8250   if (!arg2) {
8251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8252     return 0;
8253   }
8254   {
8255     try {
8256       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8257     } catch (std::out_of_range& e) {
8258       {
8259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (std::exception& e) {
8262       {
8263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (Dali::DaliException e) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8268       };
8269     } catch (...) {
8270       {
8271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8272       };
8273     }
8274   }
8275
8276   jresult = result;
8277   return jresult;
8278 }
8279
8280
8281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8282   void * jresult ;
8283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8284   Dali::Vector4 *arg2 = 0 ;
8285   Dali::Vector4 result;
8286
8287   arg1 = (Dali::Vector4 *)jarg1;
8288   arg2 = (Dali::Vector4 *)jarg2;
8289   if (!arg2) {
8290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8291     return 0;
8292   }
8293   {
8294     try {
8295       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8296     } catch (std::out_of_range& e) {
8297       {
8298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (std::exception& e) {
8301       {
8302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (Dali::DaliException e) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8307       };
8308     } catch (...) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8311       };
8312     }
8313   }
8314
8315   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8321   float jresult ;
8322   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8323   float result;
8324
8325   arg1 = (Dali::Vector4 *)jarg1;
8326   {
8327     try {
8328       result = (float)((Dali::Vector4 const *)arg1)->Length();
8329     } catch (std::out_of_range& e) {
8330       {
8331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8332       };
8333     } catch (std::exception& e) {
8334       {
8335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8336       };
8337     } catch (Dali::DaliException e) {
8338       {
8339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8340       };
8341     } catch (...) {
8342       {
8343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8344       };
8345     }
8346   }
8347
8348   jresult = result;
8349   return jresult;
8350 }
8351
8352
8353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8354   float jresult ;
8355   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8356   float result;
8357
8358   arg1 = (Dali::Vector4 *)jarg1;
8359   {
8360     try {
8361       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8362     } catch (std::out_of_range& e) {
8363       {
8364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8365       };
8366     } catch (std::exception& e) {
8367       {
8368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8369       };
8370     } catch (Dali::DaliException e) {
8371       {
8372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8373       };
8374     } catch (...) {
8375       {
8376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8377       };
8378     }
8379   }
8380
8381   jresult = result;
8382   return jresult;
8383 }
8384
8385
8386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8387   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8388
8389   arg1 = (Dali::Vector4 *)jarg1;
8390   {
8391     try {
8392       (arg1)->Normalize();
8393     } catch (std::out_of_range& e) {
8394       {
8395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8396       };
8397     } catch (std::exception& e) {
8398       {
8399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8400       };
8401     } catch (Dali::DaliException e) {
8402       {
8403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8404       };
8405     } catch (...) {
8406       {
8407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8408       };
8409     }
8410   }
8411
8412 }
8413
8414
8415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8416   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8417   Dali::Vector4 *arg2 = 0 ;
8418   Dali::Vector4 *arg3 = 0 ;
8419
8420   arg1 = (Dali::Vector4 *)jarg1;
8421   arg2 = (Dali::Vector4 *)jarg2;
8422   if (!arg2) {
8423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8424     return ;
8425   }
8426   arg3 = (Dali::Vector4 *)jarg3;
8427   if (!arg3) {
8428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8429     return ;
8430   }
8431   {
8432     try {
8433       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (Dali::DaliException e) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8449       };
8450     }
8451   }
8452
8453 }
8454
8455
8456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8457   void * jresult ;
8458   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8459   float *result = 0 ;
8460
8461   arg1 = (Dali::Vector4 *)jarg1;
8462   {
8463     try {
8464       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8465     } catch (std::out_of_range& e) {
8466       {
8467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8468       };
8469     } catch (std::exception& e) {
8470       {
8471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8472       };
8473     } catch (Dali::DaliException e) {
8474       {
8475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8480       };
8481     }
8482   }
8483
8484   jresult = (void *)result;
8485   return jresult;
8486 }
8487
8488
8489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8490   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8491   float arg2 ;
8492
8493   arg1 = (Dali::Vector4 *)jarg1;
8494   arg2 = (float)jarg2;
8495   if (arg1) (arg1)->x = arg2;
8496 }
8497
8498
8499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8500   float jresult ;
8501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8502   float result;
8503
8504   arg1 = (Dali::Vector4 *)jarg1;
8505   result = (float) ((arg1)->x);
8506   jresult = result;
8507   return jresult;
8508 }
8509
8510
8511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8512   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8513   float arg2 ;
8514
8515   arg1 = (Dali::Vector4 *)jarg1;
8516   arg2 = (float)jarg2;
8517   if (arg1) (arg1)->r = arg2;
8518 }
8519
8520
8521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8522   float jresult ;
8523   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8524   float result;
8525
8526   arg1 = (Dali::Vector4 *)jarg1;
8527   result = (float) ((arg1)->r);
8528   jresult = result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->s = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->s);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->y = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->y);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->g = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->g);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->t = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->t);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->z = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->z);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->b = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->b);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->p = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->p);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->w = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->w);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->a = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->a);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->q = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->q);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755
8756   arg1 = (Dali::Vector4 *)jarg1;
8757   {
8758     try {
8759       delete arg1;
8760     } catch (std::out_of_range& e) {
8761       {
8762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8763       };
8764     } catch (std::exception& e) {
8765       {
8766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8767       };
8768     } catch (Dali::DaliException e) {
8769       {
8770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8771       };
8772     } catch (...) {
8773       {
8774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8775       };
8776     }
8777   }
8778
8779 }
8780
8781
8782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8783   void * jresult ;
8784   Dali::Vector4 *arg1 = 0 ;
8785   Dali::Vector4 *arg2 = 0 ;
8786   Dali::Vector4 result;
8787
8788   arg1 = (Dali::Vector4 *)jarg1;
8789   if (!arg1) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8791     return 0;
8792   }
8793   arg2 = (Dali::Vector4 *)jarg2;
8794   if (!arg2) {
8795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8796     return 0;
8797   }
8798   {
8799     try {
8800       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8801     } catch (std::out_of_range& e) {
8802       {
8803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8804       };
8805     } catch (std::exception& e) {
8806       {
8807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8808       };
8809     } catch (Dali::DaliException e) {
8810       {
8811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8812       };
8813     } catch (...) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8816       };
8817     }
8818   }
8819
8820   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8826   void * jresult ;
8827   Dali::Vector4 *arg1 = 0 ;
8828   Dali::Vector4 *arg2 = 0 ;
8829   Dali::Vector4 result;
8830
8831   arg1 = (Dali::Vector4 *)jarg1;
8832   if (!arg1) {
8833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8834     return 0;
8835   }
8836   arg2 = (Dali::Vector4 *)jarg2;
8837   if (!arg2) {
8838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8839     return 0;
8840   }
8841   {
8842     try {
8843       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8844     } catch (std::out_of_range& e) {
8845       {
8846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (std::exception& e) {
8849       {
8850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (Dali::DaliException e) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8855       };
8856     } catch (...) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8859       };
8860     }
8861   }
8862
8863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8864   return jresult;
8865 }
8866
8867
8868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8869   void * jresult ;
8870   Dali::Vector4 *arg1 = 0 ;
8871   float *arg2 = 0 ;
8872   float *arg3 = 0 ;
8873   float temp2 ;
8874   float temp3 ;
8875   Dali::Vector4 result;
8876
8877   arg1 = (Dali::Vector4 *)jarg1;
8878   if (!arg1) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8880     return 0;
8881   }
8882   temp2 = (float)jarg2;
8883   arg2 = &temp2;
8884   temp3 = (float)jarg3;
8885   arg3 = &temp3;
8886   {
8887     try {
8888       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8914   void * jresult ;
8915   Dali::Uint16Pair *result = 0 ;
8916
8917   {
8918     try {
8919       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8920     } catch (std::out_of_range& e) {
8921       {
8922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (std::exception& e) {
8925       {
8926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8927       };
8928     } catch (Dali::DaliException e) {
8929       {
8930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8931       };
8932     } catch (...) {
8933       {
8934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8935       };
8936     }
8937   }
8938
8939   jresult = (void *)result;
8940   return jresult;
8941 }
8942
8943
8944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8945   void * jresult ;
8946   uint32_t arg1 ;
8947   uint32_t arg2 ;
8948   Dali::Uint16Pair *result = 0 ;
8949
8950   arg1 = (uint32_t)jarg1;
8951   arg2 = (uint32_t)jarg2;
8952   {
8953     try {
8954       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8955     } catch (std::out_of_range& e) {
8956       {
8957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (std::exception& e) {
8960       {
8961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8962       };
8963     } catch (Dali::DaliException e) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8966       };
8967     } catch (...) {
8968       {
8969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8970       };
8971     }
8972   }
8973
8974   jresult = (void *)result;
8975   return jresult;
8976 }
8977
8978
8979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8980   void * jresult ;
8981   Dali::Uint16Pair *arg1 = 0 ;
8982   Dali::Uint16Pair *result = 0 ;
8983
8984   arg1 = (Dali::Uint16Pair *)jarg1;
8985   if (!arg1) {
8986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8987     return 0;
8988   }
8989   {
8990     try {
8991       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8992     } catch (std::out_of_range& e) {
8993       {
8994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8995       };
8996     } catch (std::exception& e) {
8997       {
8998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8999       };
9000     } catch (Dali::DaliException e) {
9001       {
9002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9003       };
9004     } catch (...) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9007       };
9008     }
9009   }
9010
9011   jresult = (void *)result;
9012   return jresult;
9013 }
9014
9015
9016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9017   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9018   uint16_t arg2 ;
9019
9020   arg1 = (Dali::Uint16Pair *)jarg1;
9021   arg2 = (uint16_t)jarg2;
9022   {
9023     try {
9024       (arg1)->SetWidth(arg2);
9025     } catch (std::out_of_range& e) {
9026       {
9027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9028       };
9029     } catch (std::exception& e) {
9030       {
9031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9032       };
9033     } catch (Dali::DaliException e) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9036       };
9037     } catch (...) {
9038       {
9039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9040       };
9041     }
9042   }
9043
9044 }
9045
9046
9047 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9048   unsigned short jresult ;
9049   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9050   uint16_t result;
9051
9052   arg1 = (Dali::Uint16Pair *)jarg1;
9053   {
9054     try {
9055       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9056     } catch (std::out_of_range& e) {
9057       {
9058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9059       };
9060     } catch (std::exception& e) {
9061       {
9062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9063       };
9064     } catch (Dali::DaliException e) {
9065       {
9066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9071       };
9072     }
9073   }
9074
9075   jresult = result;
9076   return jresult;
9077 }
9078
9079
9080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9081   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9082   uint16_t arg2 ;
9083
9084   arg1 = (Dali::Uint16Pair *)jarg1;
9085   arg2 = (uint16_t)jarg2;
9086   {
9087     try {
9088       (arg1)->SetHeight(arg2);
9089     } catch (std::out_of_range& e) {
9090       {
9091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9092       };
9093     } catch (std::exception& e) {
9094       {
9095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9096       };
9097     } catch (Dali::DaliException e) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9100       };
9101     } catch (...) {
9102       {
9103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9104       };
9105     }
9106   }
9107
9108 }
9109
9110
9111 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9112   unsigned short jresult ;
9113   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9114   uint16_t result;
9115
9116   arg1 = (Dali::Uint16Pair *)jarg1;
9117   {
9118     try {
9119       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9120     } catch (std::out_of_range& e) {
9121       {
9122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9123       };
9124     } catch (std::exception& e) {
9125       {
9126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9127       };
9128     } catch (Dali::DaliException e) {
9129       {
9130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9131       };
9132     } catch (...) {
9133       {
9134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9135       };
9136     }
9137   }
9138
9139   jresult = result;
9140   return jresult;
9141 }
9142
9143
9144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9145   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9146   uint16_t arg2 ;
9147
9148   arg1 = (Dali::Uint16Pair *)jarg1;
9149   arg2 = (uint16_t)jarg2;
9150   {
9151     try {
9152       (arg1)->SetX(arg2);
9153     } catch (std::out_of_range& e) {
9154       {
9155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9156       };
9157     } catch (std::exception& e) {
9158       {
9159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9160       };
9161     } catch (Dali::DaliException e) {
9162       {
9163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9164       };
9165     } catch (...) {
9166       {
9167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9168       };
9169     }
9170   }
9171
9172 }
9173
9174
9175 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9176   unsigned short jresult ;
9177   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9178   uint16_t result;
9179
9180   arg1 = (Dali::Uint16Pair *)jarg1;
9181   {
9182     try {
9183       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9191       };
9192     } catch (Dali::DaliException e) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9195       };
9196     } catch (...) {
9197       {
9198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9199       };
9200     }
9201   }
9202
9203   jresult = result;
9204   return jresult;
9205 }
9206
9207
9208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9209   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9210   uint16_t arg2 ;
9211
9212   arg1 = (Dali::Uint16Pair *)jarg1;
9213   arg2 = (uint16_t)jarg2;
9214   {
9215     try {
9216       (arg1)->SetY(arg2);
9217     } catch (std::out_of_range& e) {
9218       {
9219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9220       };
9221     } catch (std::exception& e) {
9222       {
9223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9224       };
9225     } catch (Dali::DaliException e) {
9226       {
9227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9228       };
9229     } catch (...) {
9230       {
9231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9232       };
9233     }
9234   }
9235
9236 }
9237
9238
9239 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9240   unsigned short jresult ;
9241   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9242   uint16_t result;
9243
9244   arg1 = (Dali::Uint16Pair *)jarg1;
9245   {
9246     try {
9247       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9248     } catch (std::out_of_range& e) {
9249       {
9250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9251       };
9252     } catch (std::exception& e) {
9253       {
9254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9255       };
9256     } catch (Dali::DaliException e) {
9257       {
9258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9259       };
9260     } catch (...) {
9261       {
9262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9263       };
9264     }
9265   }
9266
9267   jresult = result;
9268   return jresult;
9269 }
9270
9271
9272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9273   void * jresult ;
9274   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9275   Dali::Uint16Pair *arg2 = 0 ;
9276   Dali::Uint16Pair *result = 0 ;
9277
9278   arg1 = (Dali::Uint16Pair *)jarg1;
9279   arg2 = (Dali::Uint16Pair *)jarg2;
9280   if (!arg2) {
9281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9282     return 0;
9283   }
9284   {
9285     try {
9286       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9287     } catch (std::out_of_range& e) {
9288       {
9289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (std::exception& e) {
9292       {
9293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9294       };
9295     } catch (Dali::DaliException e) {
9296       {
9297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9298       };
9299     } catch (...) {
9300       {
9301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9302       };
9303     }
9304   }
9305
9306   jresult = (void *)result;
9307   return jresult;
9308 }
9309
9310
9311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9312   unsigned int jresult ;
9313   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9314   Dali::Uint16Pair *arg2 = 0 ;
9315   bool result;
9316
9317   arg1 = (Dali::Uint16Pair *)jarg1;
9318   arg2 = (Dali::Uint16Pair *)jarg2;
9319   if (!arg2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9321     return 0;
9322   }
9323   {
9324     try {
9325       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (Dali::DaliException e) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9337       };
9338     } catch (...) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9341       };
9342     }
9343   }
9344
9345   jresult = result;
9346   return jresult;
9347 }
9348
9349
9350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9351   unsigned int jresult ;
9352   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9353   Dali::Uint16Pair *arg2 = 0 ;
9354   bool result;
9355
9356   arg1 = (Dali::Uint16Pair *)jarg1;
9357   arg2 = (Dali::Uint16Pair *)jarg2;
9358   if (!arg2) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9360     return 0;
9361   }
9362   {
9363     try {
9364       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9365     } catch (std::out_of_range& e) {
9366       {
9367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (std::exception& e) {
9370       {
9371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (Dali::DaliException e) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383
9384   jresult = result;
9385   return jresult;
9386 }
9387
9388
9389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9390   unsigned int jresult ;
9391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9392   Dali::Uint16Pair *arg2 = 0 ;
9393   bool result;
9394
9395   arg1 = (Dali::Uint16Pair *)jarg1;
9396   arg2 = (Dali::Uint16Pair *)jarg2;
9397   if (!arg2) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9399     return 0;
9400   }
9401   {
9402     try {
9403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9404     } catch (std::out_of_range& e) {
9405       {
9406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9407       };
9408     } catch (std::exception& e) {
9409       {
9410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (Dali::DaliException e) {
9413       {
9414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9415       };
9416     } catch (...) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9419       };
9420     }
9421   }
9422
9423   jresult = result;
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9429   unsigned int jresult ;
9430   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9431   Dali::Uint16Pair *arg2 = 0 ;
9432   bool result;
9433
9434   arg1 = (Dali::Uint16Pair *)jarg1;
9435   arg2 = (Dali::Uint16Pair *)jarg2;
9436   if (!arg2) {
9437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9438     return 0;
9439   }
9440   {
9441     try {
9442       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9443     } catch (std::out_of_range& e) {
9444       {
9445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (std::exception& e) {
9448       {
9449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (Dali::DaliException e) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9454       };
9455     } catch (...) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9458       };
9459     }
9460   }
9461
9462   jresult = result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9468   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9469
9470   arg1 = (Dali::Uint16Pair *)jarg1;
9471   {
9472     try {
9473       delete arg1;
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9481       };
9482     } catch (Dali::DaliException e) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9489       };
9490     }
9491   }
9492
9493 }
9494
9495
9496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9497   void * jresult ;
9498   Dali::Degree *result = 0 ;
9499
9500   {
9501     try {
9502       result = (Dali::Degree *)new Dali::Degree();
9503     } catch (std::out_of_range& e) {
9504       {
9505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9506       };
9507     } catch (std::exception& e) {
9508       {
9509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9510       };
9511     } catch (Dali::DaliException e) {
9512       {
9513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9514       };
9515     } catch (...) {
9516       {
9517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9518       };
9519     }
9520   }
9521
9522   jresult = (void *)result;
9523   return jresult;
9524 }
9525
9526
9527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9528   void * jresult ;
9529   float arg1 ;
9530   Dali::Degree *result = 0 ;
9531
9532   arg1 = (float)jarg1;
9533   {
9534     try {
9535       result = (Dali::Degree *)new Dali::Degree(arg1);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (Dali::DaliException e) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9547       };
9548     } catch (...) {
9549       {
9550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9551       };
9552     }
9553   }
9554
9555   jresult = (void *)result;
9556   return jresult;
9557 }
9558
9559
9560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9561   void * jresult ;
9562   Dali::Radian arg1 ;
9563   Dali::Radian *argp1 ;
9564   Dali::Degree *result = 0 ;
9565
9566   argp1 = (Dali::Radian *)jarg1;
9567   if (!argp1) {
9568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9569     return 0;
9570   }
9571   arg1 = *argp1;
9572   {
9573     try {
9574       result = (Dali::Degree *)new Dali::Degree(arg1);
9575     } catch (std::out_of_range& e) {
9576       {
9577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (std::exception& e) {
9580       {
9581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (Dali::DaliException e) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593
9594   jresult = (void *)result;
9595   return jresult;
9596 }
9597
9598
9599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9600   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9601   float arg2 ;
9602
9603   arg1 = (Dali::Degree *)jarg1;
9604   arg2 = (float)jarg2;
9605   if (arg1) (arg1)->degree = arg2;
9606 }
9607
9608
9609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9610   float jresult ;
9611   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9612   float result;
9613
9614   arg1 = (Dali::Degree *)jarg1;
9615   result = (float) ((arg1)->degree);
9616   jresult = result;
9617   return jresult;
9618 }
9619
9620
9621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9622   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9623
9624   arg1 = (Dali::Degree *)jarg1;
9625   {
9626     try {
9627       delete arg1;
9628     } catch (std::out_of_range& e) {
9629       {
9630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9631       };
9632     } catch (std::exception& e) {
9633       {
9634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9635       };
9636     } catch (Dali::DaliException e) {
9637       {
9638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9639       };
9640     } catch (...) {
9641       {
9642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9643       };
9644     }
9645   }
9646
9647 }
9648
9649
9650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9651   void * jresult ;
9652   Dali::Radian *result = 0 ;
9653
9654   result = (Dali::Radian *)&Dali::ANGLE_360;
9655   jresult = (void *)result;
9656   return jresult;
9657 }
9658
9659
9660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9661   void * jresult ;
9662   Dali::Radian *result = 0 ;
9663
9664   result = (Dali::Radian *)&Dali::ANGLE_315;
9665   jresult = (void *)result;
9666   return jresult;
9667 }
9668
9669
9670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9671   void * jresult ;
9672   Dali::Radian *result = 0 ;
9673
9674   result = (Dali::Radian *)&Dali::ANGLE_270;
9675   jresult = (void *)result;
9676   return jresult;
9677 }
9678
9679
9680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9681   void * jresult ;
9682   Dali::Radian *result = 0 ;
9683
9684   result = (Dali::Radian *)&Dali::ANGLE_225;
9685   jresult = (void *)result;
9686   return jresult;
9687 }
9688
9689
9690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9691   void * jresult ;
9692   Dali::Radian *result = 0 ;
9693
9694   result = (Dali::Radian *)&Dali::ANGLE_180;
9695   jresult = (void *)result;
9696   return jresult;
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9701   void * jresult ;
9702   Dali::Radian *result = 0 ;
9703
9704   result = (Dali::Radian *)&Dali::ANGLE_135;
9705   jresult = (void *)result;
9706   return jresult;
9707 }
9708
9709
9710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9711   void * jresult ;
9712   Dali::Radian *result = 0 ;
9713
9714   result = (Dali::Radian *)&Dali::ANGLE_120;
9715   jresult = (void *)result;
9716   return jresult;
9717 }
9718
9719
9720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9721   void * jresult ;
9722   Dali::Radian *result = 0 ;
9723
9724   result = (Dali::Radian *)&Dali::ANGLE_90;
9725   jresult = (void *)result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9731   void * jresult ;
9732   Dali::Radian *result = 0 ;
9733
9734   result = (Dali::Radian *)&Dali::ANGLE_60;
9735   jresult = (void *)result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9741   void * jresult ;
9742   Dali::Radian *result = 0 ;
9743
9744   result = (Dali::Radian *)&Dali::ANGLE_45;
9745   jresult = (void *)result;
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9751   void * jresult ;
9752   Dali::Radian *result = 0 ;
9753
9754   result = (Dali::Radian *)&Dali::ANGLE_30;
9755   jresult = (void *)result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9761   void * jresult ;
9762   Dali::Radian *result = 0 ;
9763
9764   result = (Dali::Radian *)&Dali::ANGLE_0;
9765   jresult = (void *)result;
9766   return jresult;
9767 }
9768
9769
9770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9771   unsigned int jresult ;
9772   Dali::Degree *arg1 = 0 ;
9773   Dali::Degree *arg2 = 0 ;
9774   bool result;
9775
9776   arg1 = (Dali::Degree *)jarg1;
9777   if (!arg1) {
9778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9779     return 0;
9780   }
9781   arg2 = (Dali::Degree *)jarg2;
9782   if (!arg2) {
9783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9784     return 0;
9785   }
9786   {
9787     try {
9788       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9789     } catch (std::out_of_range& e) {
9790       {
9791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9792       };
9793     } catch (std::exception& e) {
9794       {
9795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9796       };
9797     } catch (Dali::DaliException e) {
9798       {
9799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9800       };
9801     } catch (...) {
9802       {
9803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9804       };
9805     }
9806   }
9807
9808   jresult = result;
9809   return jresult;
9810 }
9811
9812
9813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9814   unsigned int jresult ;
9815   Dali::Degree *arg1 = 0 ;
9816   Dali::Degree *arg2 = 0 ;
9817   bool result;
9818
9819   arg1 = (Dali::Degree *)jarg1;
9820   if (!arg1) {
9821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9822     return 0;
9823   }
9824   arg2 = (Dali::Degree *)jarg2;
9825   if (!arg2) {
9826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9827     return 0;
9828   }
9829   {
9830     try {
9831       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9832     } catch (std::out_of_range& e) {
9833       {
9834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (std::exception& e) {
9837       {
9838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (Dali::DaliException e) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850
9851   jresult = result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9857   void * jresult ;
9858   Dali::Degree arg1 ;
9859   float arg2 ;
9860   float arg3 ;
9861   Dali::Degree *argp1 ;
9862   Dali::Degree result;
9863
9864   argp1 = (Dali::Degree *)jarg1;
9865   if (!argp1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9867     return 0;
9868   }
9869   arg1 = *argp1;
9870   arg2 = (float)jarg2;
9871   arg3 = (float)jarg3;
9872   {
9873     try {
9874       result = Dali::Clamp(arg1,arg2,arg3);
9875     } catch (std::out_of_range& e) {
9876       {
9877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (std::exception& e) {
9880       {
9881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (Dali::DaliException e) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9886       };
9887     } catch (...) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9890       };
9891     }
9892   }
9893
9894   jresult = new Dali::Degree((const Dali::Degree &)result);
9895   return jresult;
9896 }
9897
9898
9899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9900   void * jresult ;
9901   Dali::Radian *result = 0 ;
9902
9903   {
9904     try {
9905       result = (Dali::Radian *)new Dali::Radian();
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (Dali::DaliException e) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9917       };
9918     } catch (...) {
9919       {
9920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9921       };
9922     }
9923   }
9924
9925   jresult = (void *)result;
9926   return jresult;
9927 }
9928
9929
9930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9931   void * jresult ;
9932   float arg1 ;
9933   Dali::Radian *result = 0 ;
9934
9935   arg1 = (float)jarg1;
9936   {
9937     try {
9938       result = (Dali::Radian *)new Dali::Radian(arg1);
9939     } catch (std::out_of_range& e) {
9940       {
9941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (std::exception& e) {
9944       {
9945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9946       };
9947     } catch (Dali::DaliException e) {
9948       {
9949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9950       };
9951     } catch (...) {
9952       {
9953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9954       };
9955     }
9956   }
9957
9958   jresult = (void *)result;
9959   return jresult;
9960 }
9961
9962
9963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9964   void * jresult ;
9965   Dali::Degree arg1 ;
9966   Dali::Degree *argp1 ;
9967   Dali::Radian *result = 0 ;
9968
9969   argp1 = (Dali::Degree *)jarg1;
9970   if (!argp1) {
9971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9972     return 0;
9973   }
9974   arg1 = *argp1;
9975   {
9976     try {
9977       result = (Dali::Radian *)new Dali::Radian(arg1);
9978     } catch (std::out_of_range& e) {
9979       {
9980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (std::exception& e) {
9983       {
9984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (Dali::DaliException e) {
9987       {
9988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9989       };
9990     } catch (...) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9993       };
9994     }
9995   }
9996
9997   jresult = (void *)result;
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10003   void * jresult ;
10004   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10005   float arg2 ;
10006   Dali::Radian *result = 0 ;
10007
10008   arg1 = (Dali::Radian *)jarg1;
10009   arg2 = (float)jarg2;
10010   {
10011     try {
10012       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10013     } catch (std::out_of_range& e) {
10014       {
10015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (std::exception& e) {
10018       {
10019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (Dali::DaliException e) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10024       };
10025     } catch (...) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10028       };
10029     }
10030   }
10031
10032   jresult = (void *)result;
10033   return jresult;
10034 }
10035
10036
10037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10038   void * jresult ;
10039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10040   Dali::Degree arg2 ;
10041   Dali::Degree *argp2 ;
10042   Dali::Radian *result = 0 ;
10043
10044   arg1 = (Dali::Radian *)jarg1;
10045   argp2 = (Dali::Degree *)jarg2;
10046   if (!argp2) {
10047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10048     return 0;
10049   }
10050   arg2 = *argp2;
10051   {
10052     try {
10053       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (Dali::DaliException e) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10065       };
10066     } catch (...) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10069       };
10070     }
10071   }
10072
10073   jresult = (void *)result;
10074   return jresult;
10075 }
10076
10077
10078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10079   float jresult ;
10080   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10081   float result;
10082
10083   arg1 = (Dali::Radian *)jarg1;
10084   {
10085     try {
10086       result = (float)((Dali::Radian const *)arg1)->operator float();
10087     } catch (std::out_of_range& e) {
10088       {
10089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10090       };
10091     } catch (std::exception& e) {
10092       {
10093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10094       };
10095     } catch (Dali::DaliException e) {
10096       {
10097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10098       };
10099     } catch (...) {
10100       {
10101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10102       };
10103     }
10104   }
10105
10106   jresult = result;
10107   return jresult;
10108 }
10109
10110
10111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10112   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10113   float arg2 ;
10114
10115   arg1 = (Dali::Radian *)jarg1;
10116   arg2 = (float)jarg2;
10117   if (arg1) (arg1)->radian = arg2;
10118 }
10119
10120
10121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10122   float jresult ;
10123   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10124   float result;
10125
10126   arg1 = (Dali::Radian *)jarg1;
10127   result = (float) ((arg1)->radian);
10128   jresult = result;
10129   return jresult;
10130 }
10131
10132
10133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10134   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10135
10136   arg1 = (Dali::Radian *)jarg1;
10137   {
10138     try {
10139       delete arg1;
10140     } catch (std::out_of_range& e) {
10141       {
10142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10143       };
10144     } catch (std::exception& e) {
10145       {
10146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10147       };
10148     } catch (Dali::DaliException e) {
10149       {
10150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10151       };
10152     } catch (...) {
10153       {
10154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10155       };
10156     }
10157   }
10158
10159 }
10160
10161
10162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10163   unsigned int jresult ;
10164   Dali::Radian arg1 ;
10165   Dali::Radian arg2 ;
10166   Dali::Radian *argp1 ;
10167   Dali::Radian *argp2 ;
10168   bool result;
10169
10170   argp1 = (Dali::Radian *)jarg1;
10171   if (!argp1) {
10172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10173     return 0;
10174   }
10175   arg1 = *argp1;
10176   argp2 = (Dali::Radian *)jarg2;
10177   if (!argp2) {
10178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10179     return 0;
10180   }
10181   arg2 = *argp2;
10182   {
10183     try {
10184       result = (bool)Dali::operator ==(arg1,arg2);
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10200       };
10201     }
10202   }
10203
10204   jresult = result;
10205   return jresult;
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator !=(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Degree arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Degree *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Degree *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator ==(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator !=(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Degree arg1 ;
10353   Dali::Radian arg2 ;
10354   Dali::Degree *argp1 ;
10355   Dali::Radian *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Degree *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Radian *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator ==(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator !=(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Radian arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Radian *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Radian *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator >(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Degree arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Degree *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Degree *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Degree arg1 ;
10541   Dali::Radian arg2 ;
10542   Dali::Degree *argp1 ;
10543   Dali::Radian *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Degree *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Radian *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Radian arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Radian *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Radian *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator <(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Degree arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Degree *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Degree *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Degree arg1 ;
10682   Dali::Radian arg2 ;
10683   Dali::Degree *argp1 ;
10684   Dali::Radian *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Degree *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Radian *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10727   void * jresult ;
10728   Dali::Radian arg1 ;
10729   float arg2 ;
10730   Dali::Radian *argp1 ;
10731   Dali::Radian result;
10732
10733   argp1 = (Dali::Radian *)jarg1;
10734   if (!argp1) {
10735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10736     return 0;
10737   }
10738   arg1 = *argp1;
10739   arg2 = (float)jarg2;
10740   {
10741     try {
10742       result = Dali::operator *(arg1,arg2);
10743     } catch (std::out_of_range& e) {
10744       {
10745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10746       };
10747     } catch (std::exception& e) {
10748       {
10749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (Dali::DaliException e) {
10752       {
10753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761
10762   jresult = new Dali::Radian((const Dali::Radian &)result);
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10768   void * jresult ;
10769   Dali::Radian arg1 ;
10770   Dali::Radian *argp1 ;
10771   Dali::Radian result;
10772
10773   argp1 = (Dali::Radian *)jarg1;
10774   if (!argp1) {
10775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10776     return 0;
10777   }
10778   arg1 = *argp1;
10779   {
10780     try {
10781       result = Dali::operator -(arg1);
10782     } catch (std::out_of_range& e) {
10783       {
10784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10785       };
10786     } catch (std::exception& e) {
10787       {
10788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (Dali::DaliException e) {
10791       {
10792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800
10801   jresult = new Dali::Radian((const Dali::Radian &)result);
10802   return jresult;
10803 }
10804
10805
10806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10807   void * jresult ;
10808   Dali::Radian arg1 ;
10809   float arg2 ;
10810   float arg3 ;
10811   Dali::Radian *argp1 ;
10812   Dali::Radian result;
10813
10814   argp1 = (Dali::Radian *)jarg1;
10815   if (!argp1) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10817     return 0;
10818   }
10819   arg1 = *argp1;
10820   arg2 = (float)jarg2;
10821   arg3 = (float)jarg3;
10822   {
10823     try {
10824       result = Dali::Clamp(arg1,arg2,arg3);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (Dali::DaliException e) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843
10844   jresult = new Dali::Radian((const Dali::Radian &)result);
10845   return jresult;
10846 }
10847
10848
10849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10850   void * jresult ;
10851   Dali::Quaternion *result = 0 ;
10852
10853   {
10854     try {
10855       result = (Dali::Quaternion *)new Dali::Quaternion();
10856     } catch (std::out_of_range& e) {
10857       {
10858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (std::exception& e) {
10861       {
10862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10863       };
10864     } catch (Dali::DaliException e) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10867       };
10868     } catch (...) {
10869       {
10870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10871       };
10872     }
10873   }
10874
10875   jresult = (void *)result;
10876   return jresult;
10877 }
10878
10879
10880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10881   void * jresult ;
10882   Dali::Radian arg1 ;
10883   Dali::Vector3 *arg2 = 0 ;
10884   Dali::Radian *argp1 ;
10885   Dali::Quaternion *result = 0 ;
10886
10887   argp1 = (Dali::Radian *)jarg1;
10888   if (!argp1) {
10889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10890     return 0;
10891   }
10892   arg1 = *argp1;
10893   arg2 = (Dali::Vector3 *)jarg2;
10894   if (!arg2) {
10895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10896     return 0;
10897   }
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10926   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10927
10928   arg1 = (Dali::Quaternion *)jarg1;
10929   {
10930     try {
10931       delete arg1;
10932     } catch (std::out_of_range& e) {
10933       {
10934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10935       };
10936     } catch (std::exception& e) {
10937       {
10938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10939       };
10940     } catch (Dali::DaliException e) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10943       };
10944     } catch (...) {
10945       {
10946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10947       };
10948     }
10949   }
10950
10951 }
10952
10953
10954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10955   void * jresult ;
10956   Dali::Quaternion *result = 0 ;
10957
10958   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10959   jresult = (void *)result;
10960   return jresult;
10961 }
10962
10963
10964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10965   unsigned int jresult ;
10966   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10967   bool result;
10968
10969   arg1 = (Dali::Quaternion *)jarg1;
10970   {
10971     try {
10972       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10973     } catch (std::out_of_range& e) {
10974       {
10975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10976       };
10977     } catch (std::exception& e) {
10978       {
10979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10980       };
10981     } catch (Dali::DaliException e) {
10982       {
10983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10984       };
10985     } catch (...) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10988       };
10989     }
10990   }
10991
10992   jresult = result;
10993   return jresult;
10994 }
10995
10996
10997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10998   unsigned int jresult ;
10999   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11000   Dali::Vector3 *arg2 = 0 ;
11001   Dali::Radian *arg3 = 0 ;
11002   bool result;
11003
11004   arg1 = (Dali::Quaternion *)jarg1;
11005   arg2 = (Dali::Vector3 *)jarg2;
11006   if (!arg2) {
11007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11008     return 0;
11009   }
11010   arg3 = (Dali::Radian *)jarg3;
11011   if (!arg3) {
11012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11013     return 0;
11014   }
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11043   void * jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Quaternion *arg2 = 0 ;
11046   Dali::Quaternion result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Quaternion *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11052     return 0;
11053   }
11054   {
11055     try {
11056       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11057     } catch (std::out_of_range& e) {
11058       {
11059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11060       };
11061     } catch (std::exception& e) {
11062       {
11063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11064       };
11065     } catch (Dali::DaliException e) {
11066       {
11067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11068       };
11069     } catch (...) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11072       };
11073     }
11074   }
11075
11076   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11077   return jresult;
11078 }
11079
11080
11081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11082   void * jresult ;
11083   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11084   Dali::Quaternion *arg2 = 0 ;
11085   Dali::Quaternion result;
11086
11087   arg1 = (Dali::Quaternion *)jarg1;
11088   arg2 = (Dali::Quaternion *)jarg2;
11089   if (!arg2) {
11090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11091     return 0;
11092   }
11093   {
11094     try {
11095       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11096     } catch (std::out_of_range& e) {
11097       {
11098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11099       };
11100     } catch (std::exception& e) {
11101       {
11102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11103       };
11104     } catch (Dali::DaliException e) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11107       };
11108     } catch (...) {
11109       {
11110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11111       };
11112     }
11113   }
11114
11115   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11116   return jresult;
11117 }
11118
11119
11120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11121   void * jresult ;
11122   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11123   Dali::Quaternion *arg2 = 0 ;
11124   Dali::Quaternion result;
11125
11126   arg1 = (Dali::Quaternion *)jarg1;
11127   arg2 = (Dali::Quaternion *)jarg2;
11128   if (!arg2) {
11129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11130     return 0;
11131   }
11132   {
11133     try {
11134       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11135     } catch (std::out_of_range& e) {
11136       {
11137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11138       };
11139     } catch (std::exception& e) {
11140       {
11141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (Dali::DaliException e) {
11144       {
11145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153
11154   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11160   void * jresult ;
11161   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11162   Dali::Vector3 *arg2 = 0 ;
11163   Dali::Vector3 result;
11164
11165   arg1 = (Dali::Quaternion *)jarg1;
11166   arg2 = (Dali::Vector3 *)jarg2;
11167   if (!arg2) {
11168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11169     return 0;
11170   }
11171   {
11172     try {
11173       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11174     } catch (std::out_of_range& e) {
11175       {
11176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (std::exception& e) {
11179       {
11180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (Dali::DaliException e) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11185       };
11186     } catch (...) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11189       };
11190     }
11191   }
11192
11193   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11194   return jresult;
11195 }
11196
11197
11198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11199   void * jresult ;
11200   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11201   Dali::Quaternion *arg2 = 0 ;
11202   Dali::Quaternion result;
11203
11204   arg1 = (Dali::Quaternion *)jarg1;
11205   arg2 = (Dali::Quaternion *)jarg2;
11206   if (!arg2) {
11207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11208     return 0;
11209   }
11210   {
11211     try {
11212       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11213     } catch (std::out_of_range& e) {
11214       {
11215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11216       };
11217     } catch (std::exception& e) {
11218       {
11219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11220       };
11221     } catch (Dali::DaliException e) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11224       };
11225     } catch (...) {
11226       {
11227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11228       };
11229     }
11230   }
11231
11232   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11233   return jresult;
11234 }
11235
11236
11237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11238   void * jresult ;
11239   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11240   float arg2 ;
11241   Dali::Quaternion result;
11242
11243   arg1 = (Dali::Quaternion *)jarg1;
11244   arg2 = (float)jarg2;
11245   {
11246     try {
11247       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11248     } catch (std::out_of_range& e) {
11249       {
11250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (std::exception& e) {
11253       {
11254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11255       };
11256     } catch (Dali::DaliException e) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11259       };
11260     } catch (...) {
11261       {
11262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11263       };
11264     }
11265   }
11266
11267   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11268   return jresult;
11269 }
11270
11271
11272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11273   void * jresult ;
11274   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11275   float arg2 ;
11276   Dali::Quaternion result;
11277
11278   arg1 = (Dali::Quaternion *)jarg1;
11279   arg2 = (float)jarg2;
11280   {
11281     try {
11282       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11283     } catch (std::out_of_range& e) {
11284       {
11285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11286       };
11287     } catch (std::exception& e) {
11288       {
11289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11290       };
11291     } catch (Dali::DaliException e) {
11292       {
11293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11294       };
11295     } catch (...) {
11296       {
11297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11298       };
11299     }
11300   }
11301
11302   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11303   return jresult;
11304 }
11305
11306
11307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11308   void * jresult ;
11309   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11310   Dali::Quaternion result;
11311
11312   arg1 = (Dali::Quaternion *)jarg1;
11313   {
11314     try {
11315       result = ((Dali::Quaternion const *)arg1)->operator -();
11316     } catch (std::out_of_range& e) {
11317       {
11318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11319       };
11320     } catch (std::exception& e) {
11321       {
11322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11323       };
11324     } catch (Dali::DaliException e) {
11325       {
11326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11327       };
11328     } catch (...) {
11329       {
11330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11331       };
11332     }
11333   }
11334
11335   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11336   return jresult;
11337 }
11338
11339
11340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11341   void * jresult ;
11342   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11343   Dali::Quaternion *arg2 = 0 ;
11344   Dali::Quaternion *result = 0 ;
11345
11346   arg1 = (Dali::Quaternion *)jarg1;
11347   arg2 = (Dali::Quaternion *)jarg2;
11348   if (!arg2) {
11349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11350     return 0;
11351   }
11352   {
11353     try {
11354       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11355     } catch (std::out_of_range& e) {
11356       {
11357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11358       };
11359     } catch (std::exception& e) {
11360       {
11361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11362       };
11363     } catch (Dali::DaliException e) {
11364       {
11365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11366       };
11367     } catch (...) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11370       };
11371     }
11372   }
11373
11374   jresult = (void *)result;
11375   return jresult;
11376 }
11377
11378
11379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11380   void * jresult ;
11381   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11382   Dali::Quaternion *arg2 = 0 ;
11383   Dali::Quaternion *result = 0 ;
11384
11385   arg1 = (Dali::Quaternion *)jarg1;
11386   arg2 = (Dali::Quaternion *)jarg2;
11387   if (!arg2) {
11388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11389     return 0;
11390   }
11391   {
11392     try {
11393       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11394     } catch (std::out_of_range& e) {
11395       {
11396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11397       };
11398     } catch (std::exception& e) {
11399       {
11400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11401       };
11402     } catch (Dali::DaliException e) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11405       };
11406     } catch (...) {
11407       {
11408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11409       };
11410     }
11411   }
11412
11413   jresult = (void *)result;
11414   return jresult;
11415 }
11416
11417
11418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11419   void * jresult ;
11420   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11421   Dali::Quaternion *arg2 = 0 ;
11422   Dali::Quaternion *result = 0 ;
11423
11424   arg1 = (Dali::Quaternion *)jarg1;
11425   arg2 = (Dali::Quaternion *)jarg2;
11426   if (!arg2) {
11427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11428     return 0;
11429   }
11430   {
11431     try {
11432       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11433     } catch (std::out_of_range& e) {
11434       {
11435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (std::exception& e) {
11438       {
11439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (Dali::DaliException e) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11444       };
11445     } catch (...) {
11446       {
11447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11448       };
11449     }
11450   }
11451
11452   jresult = (void *)result;
11453   return jresult;
11454 }
11455
11456
11457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11458   void * jresult ;
11459   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11460   float arg2 ;
11461   Dali::Quaternion *result = 0 ;
11462
11463   arg1 = (Dali::Quaternion *)jarg1;
11464   arg2 = (float)jarg2;
11465   {
11466     try {
11467       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11468     } catch (std::out_of_range& e) {
11469       {
11470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11471       };
11472     } catch (std::exception& e) {
11473       {
11474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (Dali::DaliException e) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11479       };
11480     } catch (...) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11483       };
11484     }
11485   }
11486
11487   jresult = (void *)result;
11488   return jresult;
11489 }
11490
11491
11492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11493   void * jresult ;
11494   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11495   float arg2 ;
11496   Dali::Quaternion *result = 0 ;
11497
11498   arg1 = (Dali::Quaternion *)jarg1;
11499   arg2 = (float)jarg2;
11500   {
11501     try {
11502       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11503     } catch (std::out_of_range& e) {
11504       {
11505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (std::exception& e) {
11508       {
11509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11510       };
11511     } catch (Dali::DaliException e) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11514       };
11515     } catch (...) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11518       };
11519     }
11520   }
11521
11522   jresult = (void *)result;
11523   return jresult;
11524 }
11525
11526
11527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11528   unsigned int jresult ;
11529   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11530   Dali::Quaternion *arg2 = 0 ;
11531   bool result;
11532
11533   arg1 = (Dali::Quaternion *)jarg1;
11534   arg2 = (Dali::Quaternion *)jarg2;
11535   if (!arg2) {
11536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11537     return 0;
11538   }
11539   {
11540     try {
11541       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11542     } catch (std::out_of_range& e) {
11543       {
11544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11545       };
11546     } catch (std::exception& e) {
11547       {
11548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11549       };
11550     } catch (Dali::DaliException e) {
11551       {
11552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11553       };
11554     } catch (...) {
11555       {
11556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11557       };
11558     }
11559   }
11560
11561   jresult = result;
11562   return jresult;
11563 }
11564
11565
11566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11567   unsigned int jresult ;
11568   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11569   Dali::Quaternion *arg2 = 0 ;
11570   bool result;
11571
11572   arg1 = (Dali::Quaternion *)jarg1;
11573   arg2 = (Dali::Quaternion *)jarg2;
11574   if (!arg2) {
11575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11576     return 0;
11577   }
11578   {
11579     try {
11580       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11581     } catch (std::out_of_range& e) {
11582       {
11583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11584       };
11585     } catch (std::exception& e) {
11586       {
11587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11588       };
11589     } catch (Dali::DaliException e) {
11590       {
11591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11592       };
11593     } catch (...) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11596       };
11597     }
11598   }
11599
11600   jresult = result;
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11606   float jresult ;
11607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11608   float result;
11609
11610   arg1 = (Dali::Quaternion *)jarg1;
11611   {
11612     try {
11613       result = (float)((Dali::Quaternion const *)arg1)->Length();
11614     } catch (std::out_of_range& e) {
11615       {
11616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11617       };
11618     } catch (std::exception& e) {
11619       {
11620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11621       };
11622     } catch (Dali::DaliException e) {
11623       {
11624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11629       };
11630     }
11631   }
11632
11633   jresult = result;
11634   return jresult;
11635 }
11636
11637
11638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11639   float jresult ;
11640   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11641   float result;
11642
11643   arg1 = (Dali::Quaternion *)jarg1;
11644   {
11645     try {
11646       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11647     } catch (std::out_of_range& e) {
11648       {
11649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11650       };
11651     } catch (std::exception& e) {
11652       {
11653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11654       };
11655     } catch (Dali::DaliException e) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11658       };
11659     } catch (...) {
11660       {
11661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11662       };
11663     }
11664   }
11665
11666   jresult = result;
11667   return jresult;
11668 }
11669
11670
11671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11672   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11673
11674   arg1 = (Dali::Quaternion *)jarg1;
11675   {
11676     try {
11677       (arg1)->Normalize();
11678     } catch (std::out_of_range& e) {
11679       {
11680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11681       };
11682     } catch (std::exception& e) {
11683       {
11684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11685       };
11686     } catch (Dali::DaliException e) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11693       };
11694     }
11695   }
11696
11697 }
11698
11699
11700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11701   void * jresult ;
11702   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11703   Dali::Quaternion result;
11704
11705   arg1 = (Dali::Quaternion *)jarg1;
11706   {
11707     try {
11708       result = ((Dali::Quaternion const *)arg1)->Normalized();
11709     } catch (std::out_of_range& e) {
11710       {
11711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11712       };
11713     } catch (std::exception& e) {
11714       {
11715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11716       };
11717     } catch (Dali::DaliException e) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11720       };
11721     } catch (...) {
11722       {
11723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11724       };
11725     }
11726   }
11727
11728   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11729   return jresult;
11730 }
11731
11732
11733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11734   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11735
11736   arg1 = (Dali::Quaternion *)jarg1;
11737   {
11738     try {
11739       (arg1)->Conjugate();
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11747       };
11748     } catch (Dali::DaliException e) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11755       };
11756     }
11757   }
11758
11759 }
11760
11761
11762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11763   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11764
11765   arg1 = (Dali::Quaternion *)jarg1;
11766   {
11767     try {
11768       (arg1)->Invert();
11769     } catch (std::out_of_range& e) {
11770       {
11771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11772       };
11773     } catch (std::exception& e) {
11774       {
11775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11776       };
11777     } catch (Dali::DaliException e) {
11778       {
11779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11780       };
11781     } catch (...) {
11782       {
11783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11784       };
11785     }
11786   }
11787
11788 }
11789
11790
11791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11792   void * jresult ;
11793   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11794   Dali::Quaternion result;
11795
11796   arg1 = (Dali::Quaternion *)jarg1;
11797   {
11798     try {
11799       result = ((Dali::Quaternion const *)arg1)->Log();
11800     } catch (std::out_of_range& e) {
11801       {
11802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11803       };
11804     } catch (std::exception& e) {
11805       {
11806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11807       };
11808     } catch (Dali::DaliException e) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11815       };
11816     }
11817   }
11818
11819   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11820   return jresult;
11821 }
11822
11823
11824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11825   void * jresult ;
11826   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11827   Dali::Quaternion result;
11828
11829   arg1 = (Dali::Quaternion *)jarg1;
11830   {
11831     try {
11832       result = ((Dali::Quaternion const *)arg1)->Exp();
11833     } catch (std::out_of_range& e) {
11834       {
11835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11836       };
11837     } catch (std::exception& e) {
11838       {
11839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11840       };
11841     } catch (Dali::DaliException e) {
11842       {
11843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11844       };
11845     } catch (...) {
11846       {
11847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11848       };
11849     }
11850   }
11851
11852   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11853   return jresult;
11854 }
11855
11856
11857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11858   float jresult ;
11859   Dali::Quaternion *arg1 = 0 ;
11860   Dali::Quaternion *arg2 = 0 ;
11861   float result;
11862
11863   arg1 = (Dali::Quaternion *)jarg1;
11864   if (!arg1) {
11865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11866     return 0;
11867   }
11868   arg2 = (Dali::Quaternion *)jarg2;
11869   if (!arg2) {
11870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11871     return 0;
11872   }
11873   {
11874     try {
11875       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11876     } catch (std::out_of_range& e) {
11877       {
11878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (std::exception& e) {
11881       {
11882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (Dali::DaliException e) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11887       };
11888     } catch (...) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11891       };
11892     }
11893   }
11894
11895   jresult = result;
11896   return jresult;
11897 }
11898
11899
11900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11901   void * jresult ;
11902   Dali::Quaternion *arg1 = 0 ;
11903   Dali::Quaternion *arg2 = 0 ;
11904   float arg3 ;
11905   Dali::Quaternion result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   arg3 = (float)jarg3;
11918   {
11919     try {
11920       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   Dali::Quaternion *arg3 = 0 ;
12040   Dali::Quaternion *arg4 = 0 ;
12041   float arg5 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (Dali::Quaternion *)jarg3;
12055   if (!arg3) {
12056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12057     return 0;
12058   }
12059   arg4 = (Dali::Quaternion *)jarg4;
12060   if (!arg4) {
12061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12062     return 0;
12063   }
12064   arg5 = (float)jarg5;
12065   {
12066     try {
12067       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12068     } catch (std::out_of_range& e) {
12069       {
12070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12071       };
12072     } catch (std::exception& e) {
12073       {
12074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12075       };
12076     } catch (Dali::DaliException e) {
12077       {
12078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12079       };
12080     } catch (...) {
12081       {
12082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12083       };
12084     }
12085   }
12086
12087   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12088   return jresult;
12089 }
12090
12091
12092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12093   float jresult ;
12094   Dali::Quaternion *arg1 = 0 ;
12095   Dali::Quaternion *arg2 = 0 ;
12096   float result;
12097
12098   arg1 = (Dali::Quaternion *)jarg1;
12099   if (!arg1) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg2 = (Dali::Quaternion *)jarg2;
12104   if (!arg2) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   {
12109     try {
12110       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12111     } catch (std::out_of_range& e) {
12112       {
12113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (std::exception& e) {
12116       {
12117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (Dali::DaliException e) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12126       };
12127     }
12128   }
12129
12130   jresult = result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12136   void * jresult ;
12137   Dali::Matrix *result = 0 ;
12138
12139   {
12140     try {
12141       result = (Dali::Matrix *)new Dali::Matrix();
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12149       };
12150     } catch (Dali::DaliException e) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12153       };
12154     } catch (...) {
12155       {
12156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12157       };
12158     }
12159   }
12160
12161   jresult = (void *)result;
12162   return jresult;
12163 }
12164
12165
12166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12167   void * jresult ;
12168   bool arg1 ;
12169   Dali::Matrix *result = 0 ;
12170
12171   arg1 = jarg1 ? true : false;
12172   {
12173     try {
12174       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12175     } catch (std::out_of_range& e) {
12176       {
12177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12178       };
12179     } catch (std::exception& e) {
12180       {
12181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12182       };
12183     } catch (Dali::DaliException e) {
12184       {
12185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12186       };
12187     } catch (...) {
12188       {
12189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12190       };
12191     }
12192   }
12193
12194   jresult = (void *)result;
12195   return jresult;
12196 }
12197
12198
12199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12200   void * jresult ;
12201   float *arg1 = (float *) 0 ;
12202   Dali::Matrix *result = 0 ;
12203
12204   arg1 = jarg1;
12205   {
12206     try {
12207       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12208     } catch (std::out_of_range& e) {
12209       {
12210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12211       };
12212     } catch (std::exception& e) {
12213       {
12214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12215       };
12216     } catch (Dali::DaliException e) {
12217       {
12218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12219       };
12220     } catch (...) {
12221       {
12222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12223       };
12224     }
12225   }
12226
12227   jresult = (void *)result;
12228
12229
12230   return jresult;
12231 }
12232
12233
12234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12235   void * jresult ;
12236   Dali::Quaternion *arg1 = 0 ;
12237   Dali::Matrix *result = 0 ;
12238
12239   arg1 = (Dali::Quaternion *)jarg1;
12240   if (!arg1) {
12241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12242     return 0;
12243   }
12244   {
12245     try {
12246       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (Dali::DaliException e) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12258       };
12259     } catch (...) {
12260       {
12261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12262       };
12263     }
12264   }
12265
12266   jresult = (void *)result;
12267   return jresult;
12268 }
12269
12270
12271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12272   void * jresult ;
12273   Dali::Matrix *arg1 = 0 ;
12274   Dali::Matrix *result = 0 ;
12275
12276   arg1 = (Dali::Matrix *)jarg1;
12277   if (!arg1) {
12278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12279     return 0;
12280   }
12281   {
12282     try {
12283       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12284     } catch (std::out_of_range& e) {
12285       {
12286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12287       };
12288     } catch (std::exception& e) {
12289       {
12290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12291       };
12292     } catch (Dali::DaliException e) {
12293       {
12294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12295       };
12296     } catch (...) {
12297       {
12298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12299       };
12300     }
12301   }
12302
12303   jresult = (void *)result;
12304   return jresult;
12305 }
12306
12307
12308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12309   void * jresult ;
12310   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12311   Dali::Matrix *arg2 = 0 ;
12312   Dali::Matrix *result = 0 ;
12313
12314   arg1 = (Dali::Matrix *)jarg1;
12315   arg2 = (Dali::Matrix *)jarg2;
12316   if (!arg2) {
12317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12318     return 0;
12319   }
12320   {
12321     try {
12322       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12323     } catch (std::out_of_range& e) {
12324       {
12325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (std::exception& e) {
12328       {
12329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (Dali::DaliException e) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12334       };
12335     } catch (...) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12338       };
12339     }
12340   }
12341
12342   jresult = (void *)result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12348   void * jresult ;
12349   Dali::Matrix *result = 0 ;
12350
12351   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12352   jresult = (void *)result;
12353   return jresult;
12354 }
12355
12356
12357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12358   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12359
12360   arg1 = (Dali::Matrix *)jarg1;
12361   {
12362     try {
12363       (arg1)->SetIdentity();
12364     } catch (std::out_of_range& e) {
12365       {
12366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12367       };
12368     } catch (std::exception& e) {
12369       {
12370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12371       };
12372     } catch (Dali::DaliException e) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12375       };
12376     } catch (...) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12379       };
12380     }
12381   }
12382
12383 }
12384
12385
12386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12387   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12388   Dali::Vector3 *arg2 = 0 ;
12389
12390   arg1 = (Dali::Matrix *)jarg1;
12391   arg2 = (Dali::Vector3 *)jarg2;
12392   if (!arg2) {
12393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12394     return ;
12395   }
12396   {
12397     try {
12398       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12399     } catch (std::out_of_range& e) {
12400       {
12401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12402       };
12403     } catch (std::exception& e) {
12404       {
12405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12406       };
12407     } catch (Dali::DaliException e) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12410       };
12411     } catch (...) {
12412       {
12413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12414       };
12415     }
12416   }
12417
12418 }
12419
12420
12421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12422   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12423   Dali::Matrix *arg2 = 0 ;
12424
12425   arg1 = (Dali::Matrix *)jarg1;
12426   arg2 = (Dali::Matrix *)jarg2;
12427   if (!arg2) {
12428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12429     return ;
12430   }
12431   {
12432     try {
12433       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12434     } catch (std::out_of_range& e) {
12435       {
12436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (std::exception& e) {
12439       {
12440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12441       };
12442     } catch (Dali::DaliException e) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12445       };
12446     } catch (...) {
12447       {
12448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12449       };
12450     }
12451   }
12452
12453 }
12454
12455
12456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12457   unsigned int jresult ;
12458   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12459   bool result;
12460
12461   arg1 = (Dali::Matrix *)jarg1;
12462   {
12463     try {
12464       result = (bool)(arg1)->Invert();
12465     } catch (std::out_of_range& e) {
12466       {
12467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12468       };
12469     } catch (std::exception& e) {
12470       {
12471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12472       };
12473     } catch (Dali::DaliException e) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12480       };
12481     }
12482   }
12483
12484   jresult = result;
12485   return jresult;
12486 }
12487
12488
12489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12490   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12491
12492   arg1 = (Dali::Matrix *)jarg1;
12493   {
12494     try {
12495       (arg1)->Transpose();
12496     } catch (std::out_of_range& e) {
12497       {
12498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12499       };
12500     } catch (std::exception& e) {
12501       {
12502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12503       };
12504     } catch (Dali::DaliException e) {
12505       {
12506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12511       };
12512     }
12513   }
12514
12515 }
12516
12517
12518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12519   void * jresult ;
12520   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12521   Dali::Vector3 result;
12522
12523   arg1 = (Dali::Matrix *)jarg1;
12524   {
12525     try {
12526       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12527     } catch (std::out_of_range& e) {
12528       {
12529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12530       };
12531     } catch (std::exception& e) {
12532       {
12533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12534       };
12535     } catch (Dali::DaliException e) {
12536       {
12537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12538       };
12539     } catch (...) {
12540       {
12541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12542       };
12543     }
12544   }
12545
12546   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12552   void * jresult ;
12553   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12554   Dali::Vector3 result;
12555
12556   arg1 = (Dali::Matrix *)jarg1;
12557   {
12558     try {
12559       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12560     } catch (std::out_of_range& e) {
12561       {
12562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12563       };
12564     } catch (std::exception& e) {
12565       {
12566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12567       };
12568     } catch (Dali::DaliException e) {
12569       {
12570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12571       };
12572     } catch (...) {
12573       {
12574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12575       };
12576     }
12577   }
12578
12579   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12580   return jresult;
12581 }
12582
12583
12584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12585   void * jresult ;
12586   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12587   Dali::Vector3 result;
12588
12589   arg1 = (Dali::Matrix *)jarg1;
12590   {
12591     try {
12592       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12593     } catch (std::out_of_range& e) {
12594       {
12595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12596       };
12597     } catch (std::exception& e) {
12598       {
12599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12600       };
12601     } catch (Dali::DaliException e) {
12602       {
12603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12604       };
12605     } catch (...) {
12606       {
12607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12608       };
12609     }
12610   }
12611
12612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12613   return jresult;
12614 }
12615
12616
12617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12618   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12619   Dali::Vector3 *arg2 = 0 ;
12620
12621   arg1 = (Dali::Matrix *)jarg1;
12622   arg2 = (Dali::Vector3 *)jarg2;
12623   if (!arg2) {
12624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12625     return ;
12626   }
12627   {
12628     try {
12629       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12630     } catch (std::out_of_range& e) {
12631       {
12632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12633       };
12634     } catch (std::exception& e) {
12635       {
12636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12637       };
12638     } catch (Dali::DaliException e) {
12639       {
12640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12641       };
12642     } catch (...) {
12643       {
12644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12645       };
12646     }
12647   }
12648
12649 }
12650
12651
12652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12653   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12654   Dali::Vector3 *arg2 = 0 ;
12655
12656   arg1 = (Dali::Matrix *)jarg1;
12657   arg2 = (Dali::Vector3 *)jarg2;
12658   if (!arg2) {
12659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12660     return ;
12661   }
12662   {
12663     try {
12664       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12665     } catch (std::out_of_range& e) {
12666       {
12667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (std::exception& e) {
12670       {
12671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12672       };
12673     } catch (Dali::DaliException e) {
12674       {
12675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12676       };
12677     } catch (...) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12680       };
12681     }
12682   }
12683
12684 }
12685
12686
12687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12688   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12689   Dali::Vector3 *arg2 = 0 ;
12690
12691   arg1 = (Dali::Matrix *)jarg1;
12692   arg2 = (Dali::Vector3 *)jarg2;
12693   if (!arg2) {
12694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12695     return ;
12696   }
12697   {
12698     try {
12699       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12700     } catch (std::out_of_range& e) {
12701       {
12702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12703       };
12704     } catch (std::exception& e) {
12705       {
12706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12707       };
12708     } catch (Dali::DaliException e) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12711       };
12712     } catch (...) {
12713       {
12714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12715       };
12716     }
12717   }
12718
12719 }
12720
12721
12722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12723   void * jresult ;
12724   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12725   Dali::Vector4 *result = 0 ;
12726
12727   arg1 = (Dali::Matrix *)jarg1;
12728   {
12729     try {
12730       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12738       };
12739     } catch (Dali::DaliException e) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12742       };
12743     } catch (...) {
12744       {
12745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12746       };
12747     }
12748   }
12749
12750   jresult = (void *)result;
12751   return jresult;
12752 }
12753
12754
12755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12756   void * jresult ;
12757   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12758   Dali::Vector3 *result = 0 ;
12759
12760   arg1 = (Dali::Matrix *)jarg1;
12761   {
12762     try {
12763       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12764     } catch (std::out_of_range& e) {
12765       {
12766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (std::exception& e) {
12769       {
12770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12771       };
12772     } catch (Dali::DaliException e) {
12773       {
12774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12775       };
12776     } catch (...) {
12777       {
12778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12779       };
12780     }
12781   }
12782
12783   jresult = (void *)result;
12784   return jresult;
12785 }
12786
12787
12788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12789   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12790   Dali::Vector4 *arg2 = 0 ;
12791
12792   arg1 = (Dali::Matrix *)jarg1;
12793   arg2 = (Dali::Vector4 *)jarg2;
12794   if (!arg2) {
12795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12796     return ;
12797   }
12798   {
12799     try {
12800       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12801     } catch (std::out_of_range& e) {
12802       {
12803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12804       };
12805     } catch (std::exception& e) {
12806       {
12807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12808       };
12809     } catch (Dali::DaliException e) {
12810       {
12811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12812       };
12813     } catch (...) {
12814       {
12815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12816       };
12817     }
12818   }
12819
12820 }
12821
12822
12823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12824   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12825   Dali::Vector3 *arg2 = 0 ;
12826
12827   arg1 = (Dali::Matrix *)jarg1;
12828   arg2 = (Dali::Vector3 *)jarg2;
12829   if (!arg2) {
12830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12831     return ;
12832   }
12833   {
12834     try {
12835       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12836     } catch (std::out_of_range& e) {
12837       {
12838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12839       };
12840     } catch (std::exception& e) {
12841       {
12842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12843       };
12844     } catch (Dali::DaliException e) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12847       };
12848     } catch (...) {
12849       {
12850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12851       };
12852     }
12853   }
12854
12855 }
12856
12857
12858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12859   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12860
12861   arg1 = (Dali::Matrix *)jarg1;
12862   {
12863     try {
12864       (arg1)->OrthoNormalize();
12865     } catch (std::out_of_range& e) {
12866       {
12867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12868       };
12869     } catch (std::exception& e) {
12870       {
12871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12872       };
12873     } catch (Dali::DaliException e) {
12874       {
12875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12876       };
12877     } catch (...) {
12878       {
12879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12880       };
12881     }
12882   }
12883
12884 }
12885
12886
12887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12888   void * jresult ;
12889   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12890   float *result = 0 ;
12891
12892   arg1 = (Dali::Matrix *)jarg1;
12893   {
12894     try {
12895       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12896     } catch (std::out_of_range& e) {
12897       {
12898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12899       };
12900     } catch (std::exception& e) {
12901       {
12902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12903       };
12904     } catch (Dali::DaliException e) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12907       };
12908     } catch (...) {
12909       {
12910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12911       };
12912     }
12913   }
12914
12915   jresult = (void *)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12921   Dali::Matrix *arg1 = 0 ;
12922   Dali::Matrix *arg2 = 0 ;
12923   Dali::Matrix *arg3 = 0 ;
12924
12925   arg1 = (Dali::Matrix *)jarg1;
12926   if (!arg1) {
12927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12928     return ;
12929   }
12930   arg2 = (Dali::Matrix *)jarg2;
12931   if (!arg2) {
12932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12933     return ;
12934   }
12935   arg3 = (Dali::Matrix *)jarg3;
12936   if (!arg3) {
12937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12938     return ;
12939   }
12940   {
12941     try {
12942       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12958       };
12959     }
12960   }
12961
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Quaternion *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Quaternion *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13011   void * jresult ;
13012   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13013   Dali::Vector4 *arg2 = 0 ;
13014   Dali::Vector4 result;
13015
13016   arg1 = (Dali::Matrix *)jarg1;
13017   arg2 = (Dali::Vector4 *)jarg2;
13018   if (!arg2) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13020     return 0;
13021   }
13022   {
13023     try {
13024       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13025     } catch (std::out_of_range& e) {
13026       {
13027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13028       };
13029     } catch (std::exception& e) {
13030       {
13031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13032       };
13033     } catch (Dali::DaliException e) {
13034       {
13035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13036       };
13037     } catch (...) {
13038       {
13039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13040       };
13041     }
13042   }
13043
13044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13045   return jresult;
13046 }
13047
13048
13049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13050   unsigned int jresult ;
13051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13052   Dali::Matrix *arg2 = 0 ;
13053   bool result;
13054
13055   arg1 = (Dali::Matrix *)jarg1;
13056   arg2 = (Dali::Matrix *)jarg2;
13057   if (!arg2) {
13058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13059     return 0;
13060   }
13061   {
13062     try {
13063       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13064     } catch (std::out_of_range& e) {
13065       {
13066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13067       };
13068     } catch (std::exception& e) {
13069       {
13070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (Dali::DaliException e) {
13073       {
13074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13075       };
13076     } catch (...) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13079       };
13080     }
13081   }
13082
13083   jresult = result;
13084   return jresult;
13085 }
13086
13087
13088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13089   unsigned int jresult ;
13090   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13091   Dali::Matrix *arg2 = 0 ;
13092   bool result;
13093
13094   arg1 = (Dali::Matrix *)jarg1;
13095   arg2 = (Dali::Matrix *)jarg2;
13096   if (!arg2) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13098     return 0;
13099   }
13100   {
13101     try {
13102       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13103     } catch (std::out_of_range& e) {
13104       {
13105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13106       };
13107     } catch (std::exception& e) {
13108       {
13109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (Dali::DaliException e) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121
13122   jresult = result;
13123   return jresult;
13124 }
13125
13126
13127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13128   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13129   Dali::Vector3 *arg2 = 0 ;
13130   Dali::Quaternion *arg3 = 0 ;
13131   Dali::Vector3 *arg4 = 0 ;
13132
13133   arg1 = (Dali::Matrix *)jarg1;
13134   arg2 = (Dali::Vector3 *)jarg2;
13135   if (!arg2) {
13136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13137     return ;
13138   }
13139   arg3 = (Dali::Quaternion *)jarg3;
13140   if (!arg3) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13142     return ;
13143   }
13144   arg4 = (Dali::Vector3 *)jarg4;
13145   if (!arg4) {
13146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13147     return ;
13148   }
13149   {
13150     try {
13151       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13152     } catch (std::out_of_range& e) {
13153       {
13154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13155       };
13156     } catch (std::exception& e) {
13157       {
13158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13159       };
13160     } catch (Dali::DaliException e) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13163       };
13164     } catch (...) {
13165       {
13166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13167       };
13168     }
13169   }
13170
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Vector3 *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226   Dali::Vector3 *arg5 = 0 ;
13227
13228   arg1 = (Dali::Matrix *)jarg1;
13229   arg2 = (Dali::Vector3 *)jarg2;
13230   if (!arg2) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13232     return ;
13233   }
13234   arg3 = (Dali::Vector3 *)jarg3;
13235   if (!arg3) {
13236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13237     return ;
13238   }
13239   arg4 = (Dali::Vector3 *)jarg4;
13240   if (!arg4) {
13241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13242     return ;
13243   }
13244   arg5 = (Dali::Vector3 *)jarg5;
13245   if (!arg5) {
13246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13247     return ;
13248   }
13249   {
13250     try {
13251       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13252     } catch (std::out_of_range& e) {
13253       {
13254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13255       };
13256     } catch (std::exception& e) {
13257       {
13258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13259       };
13260     } catch (Dali::DaliException e) {
13261       {
13262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13263       };
13264     } catch (...) {
13265       {
13266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13267       };
13268     }
13269   }
13270
13271 }
13272
13273
13274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13275   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13276   Dali::Vector3 *arg2 = 0 ;
13277   Dali::Quaternion *arg3 = 0 ;
13278   Dali::Vector3 *arg4 = 0 ;
13279
13280   arg1 = (Dali::Matrix *)jarg1;
13281   arg2 = (Dali::Vector3 *)jarg2;
13282   if (!arg2) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13284     return ;
13285   }
13286   arg3 = (Dali::Quaternion *)jarg3;
13287   if (!arg3) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13289     return ;
13290   }
13291   arg4 = (Dali::Vector3 *)jarg4;
13292   if (!arg4) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   {
13326     try {
13327       delete arg1;
13328     } catch (std::out_of_range& e) {
13329       {
13330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13331       };
13332     } catch (std::exception& e) {
13333       {
13334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13335       };
13336     } catch (Dali::DaliException e) {
13337       {
13338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13339       };
13340     } catch (...) {
13341       {
13342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13343       };
13344     }
13345   }
13346
13347 }
13348
13349
13350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13351   void * jresult ;
13352   Dali::Matrix3 *result = 0 ;
13353
13354   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13355   jresult = (void *)result;
13356   return jresult;
13357 }
13358
13359
13360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13361   void * jresult ;
13362   Dali::Matrix3 *result = 0 ;
13363
13364   {
13365     try {
13366       result = (Dali::Matrix3 *)new Dali::Matrix3();
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13374       };
13375     } catch (Dali::DaliException e) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13378       };
13379     } catch (...) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13382       };
13383     }
13384   }
13385
13386   jresult = (void *)result;
13387   return jresult;
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13392   void * jresult ;
13393   Dali::Matrix3 *arg1 = 0 ;
13394   Dali::Matrix3 *result = 0 ;
13395
13396   arg1 = (Dali::Matrix3 *)jarg1;
13397   if (!arg1) {
13398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13399     return 0;
13400   }
13401   {
13402     try {
13403       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13404     } catch (std::out_of_range& e) {
13405       {
13406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13407       };
13408     } catch (std::exception& e) {
13409       {
13410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13411       };
13412     } catch (Dali::DaliException e) {
13413       {
13414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13415       };
13416     } catch (...) {
13417       {
13418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13419       };
13420     }
13421   }
13422
13423   jresult = (void *)result;
13424   return jresult;
13425 }
13426
13427
13428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13429   void * jresult ;
13430   Dali::Matrix *arg1 = 0 ;
13431   Dali::Matrix3 *result = 0 ;
13432
13433   arg1 = (Dali::Matrix *)jarg1;
13434   if (!arg1) {
13435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13436     return 0;
13437   }
13438   {
13439     try {
13440       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13441     } catch (std::out_of_range& e) {
13442       {
13443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13444       };
13445     } catch (std::exception& e) {
13446       {
13447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13448       };
13449     } catch (Dali::DaliException e) {
13450       {
13451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13452       };
13453     } catch (...) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13456       };
13457     }
13458   }
13459
13460   jresult = (void *)result;
13461   return jresult;
13462 }
13463
13464
13465 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) {
13466   void * jresult ;
13467   float arg1 ;
13468   float arg2 ;
13469   float arg3 ;
13470   float arg4 ;
13471   float arg5 ;
13472   float arg6 ;
13473   float arg7 ;
13474   float arg8 ;
13475   float arg9 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (float)jarg1;
13479   arg2 = (float)jarg2;
13480   arg3 = (float)jarg3;
13481   arg4 = (float)jarg4;
13482   arg5 = (float)jarg5;
13483   arg6 = (float)jarg6;
13484   arg7 = (float)jarg7;
13485   arg8 = (float)jarg8;
13486   arg9 = (float)jarg9;
13487   {
13488     try {
13489       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13490     } catch (std::out_of_range& e) {
13491       {
13492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (std::exception& e) {
13495       {
13496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13497       };
13498     } catch (Dali::DaliException e) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13501       };
13502     } catch (...) {
13503       {
13504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13505       };
13506     }
13507   }
13508
13509   jresult = (void *)result;
13510   return jresult;
13511 }
13512
13513
13514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13515   void * jresult ;
13516   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13517   Dali::Matrix3 *arg2 = 0 ;
13518   Dali::Matrix3 *result = 0 ;
13519
13520   arg1 = (Dali::Matrix3 *)jarg1;
13521   arg2 = (Dali::Matrix3 *)jarg2;
13522   if (!arg2) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13524     return 0;
13525   }
13526   {
13527     try {
13528       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (Dali::DaliException e) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13540       };
13541     } catch (...) {
13542       {
13543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13544       };
13545     }
13546   }
13547
13548   jresult = (void *)result;
13549   return jresult;
13550 }
13551
13552
13553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13554   void * jresult ;
13555   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13556   Dali::Matrix *arg2 = 0 ;
13557   Dali::Matrix3 *result = 0 ;
13558
13559   arg1 = (Dali::Matrix3 *)jarg1;
13560   arg2 = (Dali::Matrix *)jarg2;
13561   if (!arg2) {
13562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13563     return 0;
13564   }
13565   {
13566     try {
13567       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13568     } catch (std::out_of_range& e) {
13569       {
13570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (std::exception& e) {
13573       {
13574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (Dali::DaliException e) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13579       };
13580     } catch (...) {
13581       {
13582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13583       };
13584     }
13585   }
13586
13587   jresult = (void *)result;
13588   return jresult;
13589 }
13590
13591
13592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13593   unsigned int jresult ;
13594   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13595   Dali::Matrix3 *arg2 = 0 ;
13596   bool result;
13597
13598   arg1 = (Dali::Matrix3 *)jarg1;
13599   arg2 = (Dali::Matrix3 *)jarg2;
13600   if (!arg2) {
13601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13602     return 0;
13603   }
13604   {
13605     try {
13606       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13607     } catch (std::out_of_range& e) {
13608       {
13609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13610       };
13611     } catch (std::exception& e) {
13612       {
13613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (Dali::DaliException e) {
13616       {
13617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13618       };
13619     } catch (...) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13622       };
13623     }
13624   }
13625
13626   jresult = result;
13627   return jresult;
13628 }
13629
13630
13631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13632   unsigned int jresult ;
13633   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13634   Dali::Matrix3 *arg2 = 0 ;
13635   bool result;
13636
13637   arg1 = (Dali::Matrix3 *)jarg1;
13638   arg2 = (Dali::Matrix3 *)jarg2;
13639   if (!arg2) {
13640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13641     return 0;
13642   }
13643   {
13644     try {
13645       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13646     } catch (std::out_of_range& e) {
13647       {
13648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (std::exception& e) {
13651       {
13652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13653       };
13654     } catch (Dali::DaliException e) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13657       };
13658     } catch (...) {
13659       {
13660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13661       };
13662     }
13663   }
13664
13665   jresult = result;
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13671   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13672
13673   arg1 = (Dali::Matrix3 *)jarg1;
13674   {
13675     try {
13676       delete arg1;
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13684       };
13685     } catch (Dali::DaliException e) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13692       };
13693     }
13694   }
13695
13696 }
13697
13698
13699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13700   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13701
13702   arg1 = (Dali::Matrix3 *)jarg1;
13703   {
13704     try {
13705       (arg1)->SetIdentity();
13706     } catch (std::out_of_range& e) {
13707       {
13708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13709       };
13710     } catch (std::exception& e) {
13711       {
13712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13713       };
13714     } catch (Dali::DaliException e) {
13715       {
13716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13717       };
13718     } catch (...) {
13719       {
13720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13721       };
13722     }
13723   }
13724
13725 }
13726
13727
13728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13729   void * jresult ;
13730   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13731   float *result = 0 ;
13732
13733   arg1 = (Dali::Matrix3 *)jarg1;
13734   {
13735     try {
13736       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13737     } catch (std::out_of_range& e) {
13738       {
13739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13740       };
13741     } catch (std::exception& e) {
13742       {
13743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13744       };
13745     } catch (Dali::DaliException e) {
13746       {
13747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13748       };
13749     } catch (...) {
13750       {
13751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13752       };
13753     }
13754   }
13755
13756   jresult = (void *)result;
13757   return jresult;
13758 }
13759
13760
13761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13762   unsigned int jresult ;
13763   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13764   bool result;
13765
13766   arg1 = (Dali::Matrix3 *)jarg1;
13767   {
13768     try {
13769       result = (bool)(arg1)->Invert();
13770     } catch (std::out_of_range& e) {
13771       {
13772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13773       };
13774     } catch (std::exception& e) {
13775       {
13776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13777       };
13778     } catch (Dali::DaliException e) {
13779       {
13780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13781       };
13782     } catch (...) {
13783       {
13784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13785       };
13786     }
13787   }
13788
13789   jresult = result;
13790   return jresult;
13791 }
13792
13793
13794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13795   unsigned int jresult ;
13796   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13797   bool result;
13798
13799   arg1 = (Dali::Matrix3 *)jarg1;
13800   {
13801     try {
13802       result = (bool)(arg1)->Transpose();
13803     } catch (std::out_of_range& e) {
13804       {
13805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13806       };
13807     } catch (std::exception& e) {
13808       {
13809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13810       };
13811     } catch (Dali::DaliException e) {
13812       {
13813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13814       };
13815     } catch (...) {
13816       {
13817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13818       };
13819     }
13820   }
13821
13822   jresult = result;
13823   return jresult;
13824 }
13825
13826
13827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13828   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13829   float arg2 ;
13830
13831   arg1 = (Dali::Matrix3 *)jarg1;
13832   arg2 = (float)jarg2;
13833   {
13834     try {
13835       (arg1)->Scale(arg2);
13836     } catch (std::out_of_range& e) {
13837       {
13838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13839       };
13840     } catch (std::exception& e) {
13841       {
13842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13843       };
13844     } catch (Dali::DaliException e) {
13845       {
13846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13847       };
13848     } catch (...) {
13849       {
13850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13851       };
13852     }
13853   }
13854
13855 }
13856
13857
13858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13859   float jresult ;
13860   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13861   float result;
13862
13863   arg1 = (Dali::Matrix3 *)jarg1;
13864   {
13865     try {
13866       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13867     } catch (std::out_of_range& e) {
13868       {
13869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13870       };
13871     } catch (std::exception& e) {
13872       {
13873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13874       };
13875     } catch (Dali::DaliException e) {
13876       {
13877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13878       };
13879     } catch (...) {
13880       {
13881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13882       };
13883     }
13884   }
13885
13886   jresult = result;
13887   return jresult;
13888 }
13889
13890
13891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13892   unsigned int jresult ;
13893   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13894   bool result;
13895
13896   arg1 = (Dali::Matrix3 *)jarg1;
13897   {
13898     try {
13899       result = (bool)(arg1)->ScaledInverseTranspose();
13900     } catch (std::out_of_range& e) {
13901       {
13902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13903       };
13904     } catch (std::exception& e) {
13905       {
13906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13907       };
13908     } catch (Dali::DaliException e) {
13909       {
13910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13911       };
13912     } catch (...) {
13913       {
13914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13915       };
13916     }
13917   }
13918
13919   jresult = result;
13920   return jresult;
13921 }
13922
13923
13924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13925   Dali::Matrix3 *arg1 = 0 ;
13926   Dali::Matrix3 *arg2 = 0 ;
13927   Dali::Matrix3 *arg3 = 0 ;
13928
13929   arg1 = (Dali::Matrix3 *)jarg1;
13930   if (!arg1) {
13931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13932     return ;
13933   }
13934   arg2 = (Dali::Matrix3 *)jarg2;
13935   if (!arg2) {
13936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13937     return ;
13938   }
13939   arg3 = (Dali::Matrix3 *)jarg3;
13940   if (!arg3) {
13941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13942     return ;
13943   }
13944   {
13945     try {
13946       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13962       };
13963     }
13964   }
13965
13966 }
13967
13968
13969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13970   float jresult ;
13971   float arg1 ;
13972   float arg2 ;
13973   float result;
13974
13975   arg1 = (float)jarg1;
13976   arg2 = (float)jarg2;
13977   {
13978     try {
13979       result = (float)Dali::Random::Range(arg1,arg2);
13980     } catch (std::out_of_range& e) {
13981       {
13982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13983       };
13984     } catch (std::exception& e) {
13985       {
13986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13987       };
13988     } catch (Dali::DaliException e) {
13989       {
13990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13991       };
13992     } catch (...) {
13993       {
13994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13995       };
13996     }
13997   }
13998
13999   jresult = result;
14000   return jresult;
14001 }
14002
14003
14004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14005   void * jresult ;
14006   Dali::Vector4 result;
14007
14008   {
14009     try {
14010       result = Dali::Random::Axis();
14011     } catch (std::out_of_range& e) {
14012       {
14013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14014       };
14015     } catch (std::exception& e) {
14016       {
14017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14018       };
14019     } catch (Dali::DaliException e) {
14020       {
14021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14022       };
14023     } catch (...) {
14024       {
14025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14026       };
14027     }
14028   }
14029
14030   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14031   return jresult;
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14036   void * jresult ;
14037   Dali::AngleAxis *result = 0 ;
14038
14039   {
14040     try {
14041       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14042     } catch (std::out_of_range& e) {
14043       {
14044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (std::exception& e) {
14047       {
14048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14049       };
14050     } catch (Dali::DaliException e) {
14051       {
14052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14057       };
14058     }
14059   }
14060
14061   jresult = (void *)result;
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14067   void * jresult ;
14068   Dali::Radian arg1 ;
14069   Dali::Vector3 *arg2 = 0 ;
14070   Dali::Radian *argp1 ;
14071   Dali::AngleAxis *result = 0 ;
14072
14073   argp1 = (Dali::Radian *)jarg1;
14074   if (!argp1) {
14075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14076     return 0;
14077   }
14078   arg1 = *argp1;
14079   arg2 = (Dali::Vector3 *)jarg2;
14080   if (!arg2) {
14081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14082     return 0;
14083   }
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14112   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14113   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14114
14115   arg1 = (Dali::AngleAxis *)jarg1;
14116   arg2 = (Dali::Radian *)jarg2;
14117   if (arg1) (arg1)->angle = *arg2;
14118 }
14119
14120
14121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14122   void * jresult ;
14123   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14124   Dali::Radian *result = 0 ;
14125
14126   arg1 = (Dali::AngleAxis *)jarg1;
14127   result = (Dali::Radian *)& ((arg1)->angle);
14128   jresult = (void *)result;
14129   return jresult;
14130 }
14131
14132
14133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14134   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14135   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14136
14137   arg1 = (Dali::AngleAxis *)jarg1;
14138   arg2 = (Dali::Vector3 *)jarg2;
14139   if (arg1) (arg1)->axis = *arg2;
14140 }
14141
14142
14143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14144   void * jresult ;
14145   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14146   Dali::Vector3 *result = 0 ;
14147
14148   arg1 = (Dali::AngleAxis *)jarg1;
14149   result = (Dali::Vector3 *)& ((arg1)->axis);
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157
14158   arg1 = (Dali::AngleAxis *)jarg1;
14159   {
14160     try {
14161       delete arg1;
14162     } catch (std::out_of_range& e) {
14163       {
14164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14165       };
14166     } catch (std::exception& e) {
14167       {
14168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14169       };
14170     } catch (Dali::DaliException e) {
14171       {
14172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14173       };
14174     } catch (...) {
14175       {
14176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14177       };
14178     }
14179   }
14180
14181 }
14182
14183
14184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14185   unsigned int jresult ;
14186   Dali::AngleAxis *arg1 = 0 ;
14187   Dali::AngleAxis *arg2 = 0 ;
14188   bool result;
14189
14190   arg1 = (Dali::AngleAxis *)jarg1;
14191   if (!arg1) {
14192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14193     return 0;
14194   }
14195   arg2 = (Dali::AngleAxis *)jarg2;
14196   if (!arg2) {
14197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14198     return 0;
14199   }
14200   {
14201     try {
14202       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14203     } catch (std::out_of_range& e) {
14204       {
14205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (std::exception& e) {
14208       {
14209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14210       };
14211     } catch (Dali::DaliException e) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14214       };
14215     } catch (...) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14218       };
14219     }
14220   }
14221
14222   jresult = result;
14223   return jresult;
14224 }
14225
14226
14227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14228   unsigned int jresult ;
14229   unsigned int arg1 ;
14230   unsigned int result;
14231
14232   arg1 = (unsigned int)jarg1;
14233   {
14234     try {
14235       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14236     } catch (std::out_of_range& e) {
14237       {
14238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14239       };
14240     } catch (std::exception& e) {
14241       {
14242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14243       };
14244     } catch (Dali::DaliException e) {
14245       {
14246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14247       };
14248     } catch (...) {
14249       {
14250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14251       };
14252     }
14253   }
14254
14255   jresult = result;
14256   return jresult;
14257 }
14258
14259
14260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14261   unsigned int jresult ;
14262   unsigned int arg1 ;
14263   bool result;
14264
14265   arg1 = (unsigned int)jarg1;
14266   {
14267     try {
14268       result = (bool)Dali::IsPowerOfTwo(arg1);
14269     } catch (std::out_of_range& e) {
14270       {
14271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14272       };
14273     } catch (std::exception& e) {
14274       {
14275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14276       };
14277     } catch (Dali::DaliException e) {
14278       {
14279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14280       };
14281     } catch (...) {
14282       {
14283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14284       };
14285     }
14286   }
14287
14288   jresult = result;
14289   return jresult;
14290 }
14291
14292
14293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14294   float jresult ;
14295   float arg1 ;
14296   float arg2 ;
14297   float result;
14298
14299   arg1 = (float)jarg1;
14300   arg2 = (float)jarg2;
14301   {
14302     try {
14303       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14304     } catch (std::out_of_range& e) {
14305       {
14306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14307       };
14308     } catch (std::exception& e) {
14309       {
14310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (Dali::DaliException e) {
14313       {
14314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14315       };
14316     } catch (...) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14319       };
14320     }
14321   }
14322
14323   jresult = result;
14324   return jresult;
14325 }
14326
14327
14328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14329   unsigned int jresult ;
14330   float arg1 ;
14331   bool result;
14332
14333   arg1 = (float)jarg1;
14334   {
14335     try {
14336       result = (bool)Dali::EqualsZero(arg1);
14337     } catch (std::out_of_range& e) {
14338       {
14339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14340       };
14341     } catch (std::exception& e) {
14342       {
14343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14344       };
14345     } catch (Dali::DaliException e) {
14346       {
14347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14348       };
14349     } catch (...) {
14350       {
14351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14352       };
14353     }
14354   }
14355
14356   jresult = result;
14357   return jresult;
14358 }
14359
14360
14361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14362   unsigned int jresult ;
14363   float arg1 ;
14364   float arg2 ;
14365   bool result;
14366
14367   arg1 = (float)jarg1;
14368   arg2 = (float)jarg2;
14369   {
14370     try {
14371       result = (bool)Dali::Equals(arg1,arg2);
14372     } catch (std::out_of_range& e) {
14373       {
14374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (std::exception& e) {
14377       {
14378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14379       };
14380     } catch (Dali::DaliException e) {
14381       {
14382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14383       };
14384     } catch (...) {
14385       {
14386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14387       };
14388     }
14389   }
14390
14391   jresult = result;
14392   return jresult;
14393 }
14394
14395
14396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14397   unsigned int jresult ;
14398   float arg1 ;
14399   float arg2 ;
14400   float arg3 ;
14401   bool result;
14402
14403   arg1 = (float)jarg1;
14404   arg2 = (float)jarg2;
14405   arg3 = (float)jarg3;
14406   {
14407     try {
14408       result = (bool)Dali::Equals(arg1,arg2,arg3);
14409     } catch (std::out_of_range& e) {
14410       {
14411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14412       };
14413     } catch (std::exception& e) {
14414       {
14415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14416       };
14417     } catch (Dali::DaliException e) {
14418       {
14419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14420       };
14421     } catch (...) {
14422       {
14423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14424       };
14425     }
14426   }
14427
14428   jresult = result;
14429   return jresult;
14430 }
14431
14432
14433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14434   float jresult ;
14435   float arg1 ;
14436   int arg2 ;
14437   float result;
14438
14439   arg1 = (float)jarg1;
14440   arg2 = (int)jarg2;
14441   {
14442     try {
14443       result = (float)Dali::Round(arg1,arg2);
14444     } catch (std::out_of_range& e) {
14445       {
14446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (std::exception& e) {
14449       {
14450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (Dali::DaliException e) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14455       };
14456     } catch (...) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14459       };
14460     }
14461   }
14462
14463   jresult = result;
14464   return jresult;
14465 }
14466
14467
14468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14469   float jresult ;
14470   float arg1 ;
14471   float arg2 ;
14472   float arg3 ;
14473   float result;
14474
14475   arg1 = (float)jarg1;
14476   arg2 = (float)jarg2;
14477   arg3 = (float)jarg3;
14478   {
14479     try {
14480       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14481     } catch (std::out_of_range& e) {
14482       {
14483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14484       };
14485     } catch (std::exception& e) {
14486       {
14487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14488       };
14489     } catch (Dali::DaliException e) {
14490       {
14491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14492       };
14493     } catch (...) {
14494       {
14495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14496       };
14497     }
14498   }
14499
14500   jresult = result;
14501   return jresult;
14502 }
14503
14504
14505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14506   float jresult ;
14507   float arg1 ;
14508   float arg2 ;
14509   float arg3 ;
14510   float arg4 ;
14511   float result;
14512
14513   arg1 = (float)jarg1;
14514   arg2 = (float)jarg2;
14515   arg3 = (float)jarg3;
14516   arg4 = (float)jarg4;
14517   {
14518     try {
14519       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14520     } catch (std::out_of_range& e) {
14521       {
14522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14523       };
14524     } catch (std::exception& e) {
14525       {
14526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14527       };
14528     } catch (Dali::DaliException e) {
14529       {
14530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14531       };
14532     } catch (...) {
14533       {
14534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14535       };
14536     }
14537   }
14538
14539   jresult = result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14545   int jresult ;
14546   int result;
14547
14548   result = (int)(int)Dali::Property::INVALID_INDEX;
14549   jresult = result;
14550   return jresult;
14551 }
14552
14553
14554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14555   int jresult ;
14556   int result;
14557
14558   result = (int)(int)Dali::Property::INVALID_KEY;
14559   jresult = result;
14560   return jresult;
14561 }
14562
14563
14564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14565   int jresult ;
14566   int result;
14567
14568   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14569   jresult = result;
14570   return jresult;
14571 }
14572
14573
14574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14575   void * jresult ;
14576   Dali::Handle *arg1 = 0 ;
14577   Dali::Property::Index arg2 ;
14578   Dali::Property *result = 0 ;
14579
14580   arg1 = (Dali::Handle *)jarg1;
14581   if (!arg1) {
14582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14583     return 0;
14584   }
14585   arg2 = (Dali::Property::Index)jarg2;
14586   {
14587     try {
14588       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14589     } catch (std::out_of_range& e) {
14590       {
14591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14592       };
14593     } catch (std::exception& e) {
14594       {
14595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14596       };
14597     } catch (Dali::DaliException e) {
14598       {
14599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14600       };
14601     } catch (...) {
14602       {
14603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14604       };
14605     }
14606   }
14607
14608   jresult = (void *)result;
14609   return jresult;
14610 }
14611
14612
14613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14614   void * jresult ;
14615   Dali::Handle *arg1 = 0 ;
14616   Dali::Property::Index arg2 ;
14617   int arg3 ;
14618   Dali::Property *result = 0 ;
14619
14620   arg1 = (Dali::Handle *)jarg1;
14621   if (!arg1) {
14622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14623     return 0;
14624   }
14625   arg2 = (Dali::Property::Index)jarg2;
14626   arg3 = (int)jarg3;
14627   {
14628     try {
14629       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (Dali::DaliException e) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14645       };
14646     }
14647   }
14648
14649   jresult = (void *)result;
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14655   void * jresult ;
14656   Dali::Handle *arg1 = 0 ;
14657   std::string *arg2 = 0 ;
14658   Dali::Property *result = 0 ;
14659
14660   arg1 = (Dali::Handle *)jarg1;
14661   if (!arg1) {
14662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14663     return 0;
14664   }
14665   if (!jarg2) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14667     return 0;
14668   }
14669   std::string arg2_str(jarg2);
14670   arg2 = &arg2_str;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694
14695   //argout typemap for const std::string&
14696
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   int arg3 ;
14706   Dali::Property *result = 0 ;
14707
14708   arg1 = (Dali::Handle *)jarg1;
14709   if (!arg1) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14711     return 0;
14712   }
14713   if (!jarg2) {
14714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14715     return 0;
14716   }
14717   std::string arg2_str(jarg2);
14718   arg2 = &arg2_str;
14719   arg3 = (int)jarg3;
14720   {
14721     try {
14722       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14723     } catch (std::out_of_range& e) {
14724       {
14725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (std::exception& e) {
14728       {
14729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14730       };
14731     } catch (Dali::DaliException e) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14734       };
14735     } catch (...) {
14736       {
14737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14738       };
14739     }
14740   }
14741
14742   jresult = (void *)result;
14743
14744   //argout typemap for const std::string&
14745
14746   return jresult;
14747 }
14748
14749
14750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14751   Dali::Property *arg1 = (Dali::Property *) 0 ;
14752
14753   arg1 = (Dali::Property *)jarg1;
14754   {
14755     try {
14756       delete arg1;
14757     } catch (std::out_of_range& e) {
14758       {
14759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14760       };
14761     } catch (std::exception& e) {
14762       {
14763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14764       };
14765     } catch (Dali::DaliException e) {
14766       {
14767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14768       };
14769     } catch (...) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14772       };
14773     }
14774   }
14775
14776 }
14777
14778
14779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14780   Dali::Property *arg1 = (Dali::Property *) 0 ;
14781   Dali::Handle *arg2 = 0 ;
14782
14783   arg1 = (Dali::Property *)jarg1;
14784   arg2 = (Dali::Handle *)jarg2;
14785   if (!arg2) {
14786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14787     return ;
14788   }
14789   if (arg1) (arg1)->object = *arg2;
14790 }
14791
14792
14793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14794   void * jresult ;
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796   Dali::Handle *result = 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14800   jresult = (void *)result;
14801   return jresult;
14802 }
14803
14804
14805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14806   Dali::Property *arg1 = (Dali::Property *) 0 ;
14807   Dali::Property::Index arg2 ;
14808
14809   arg1 = (Dali::Property *)jarg1;
14810   arg2 = (Dali::Property::Index)jarg2;
14811   if (arg1) (arg1)->propertyIndex = arg2;
14812 }
14813
14814
14815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14816   int jresult ;
14817   Dali::Property *arg1 = (Dali::Property *) 0 ;
14818   Dali::Property::Index result;
14819
14820   arg1 = (Dali::Property *)jarg1;
14821   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14822   jresult = result;
14823   return jresult;
14824 }
14825
14826
14827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14828   Dali::Property *arg1 = (Dali::Property *) 0 ;
14829   int arg2 ;
14830
14831   arg1 = (Dali::Property *)jarg1;
14832   arg2 = (int)jarg2;
14833   if (arg1) (arg1)->componentIndex = arg2;
14834 }
14835
14836
14837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14838   int jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   int result;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (int) ((arg1)->componentIndex);
14844   jresult = result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14850   void * jresult ;
14851   Dali::Property::Array *result = 0 ;
14852
14853   {
14854     try {
14855       result = (Dali::Property::Array *)new Dali::Property::Array();
14856     } catch (std::out_of_range& e) {
14857       {
14858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (std::exception& e) {
14861       {
14862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14863       };
14864     } catch (Dali::DaliException e) {
14865       {
14866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14867       };
14868     } catch (...) {
14869       {
14870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14871       };
14872     }
14873   }
14874
14875   jresult = (void *)result;
14876   return jresult;
14877 }
14878
14879
14880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14881   void * jresult ;
14882   Dali::Property::Array *arg1 = 0 ;
14883   Dali::Property::Array *result = 0 ;
14884
14885   arg1 = (Dali::Property::Array *)jarg1;
14886   if (!arg1) {
14887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14888     return 0;
14889   }
14890   {
14891     try {
14892       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14893     } catch (std::out_of_range& e) {
14894       {
14895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (std::exception& e) {
14898       {
14899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14900       };
14901     } catch (Dali::DaliException e) {
14902       {
14903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14904       };
14905     } catch (...) {
14906       {
14907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14908       };
14909     }
14910   }
14911
14912   jresult = (void *)result;
14913   return jresult;
14914 }
14915
14916
14917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14918   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14919
14920   arg1 = (Dali::Property::Array *)jarg1;
14921   {
14922     try {
14923       delete arg1;
14924     } catch (std::out_of_range& e) {
14925       {
14926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14927       };
14928     } catch (std::exception& e) {
14929       {
14930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14931       };
14932     } catch (Dali::DaliException e) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14935       };
14936     } catch (...) {
14937       {
14938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14939       };
14940     }
14941   }
14942
14943 }
14944
14945
14946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14947   unsigned long jresult ;
14948   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14949   Dali::Property::Array::SizeType result;
14950
14951   arg1 = (Dali::Property::Array *)jarg1;
14952   {
14953     try {
14954       result = ((Dali::Property::Array const *)arg1)->Size();
14955     } catch (std::out_of_range& e) {
14956       {
14957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14958       };
14959     } catch (std::exception& e) {
14960       {
14961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14962       };
14963     } catch (Dali::DaliException e) {
14964       {
14965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14966       };
14967     } catch (...) {
14968       {
14969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14970       };
14971     }
14972   }
14973
14974   jresult = (unsigned long)result;
14975   return jresult;
14976 }
14977
14978
14979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14980   unsigned long jresult ;
14981   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14982   Dali::Property::Array::SizeType result;
14983
14984   arg1 = (Dali::Property::Array *)jarg1;
14985   {
14986     try {
14987       result = ((Dali::Property::Array const *)arg1)->Count();
14988     } catch (std::out_of_range& e) {
14989       {
14990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14991       };
14992     } catch (std::exception& e) {
14993       {
14994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14995       };
14996     } catch (Dali::DaliException e) {
14997       {
14998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14999       };
15000     } catch (...) {
15001       {
15002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15003       };
15004     }
15005   }
15006
15007   jresult = (unsigned long)result;
15008   return jresult;
15009 }
15010
15011
15012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15013   unsigned int jresult ;
15014   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15015   bool result;
15016
15017   arg1 = (Dali::Property::Array *)jarg1;
15018   {
15019     try {
15020       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15021     } catch (std::out_of_range& e) {
15022       {
15023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (std::exception& e) {
15026       {
15027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15028       };
15029     } catch (Dali::DaliException e) {
15030       {
15031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15032       };
15033     } catch (...) {
15034       {
15035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15036       };
15037     }
15038   }
15039
15040   jresult = result;
15041   return jresult;
15042 }
15043
15044
15045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15046   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15047
15048   arg1 = (Dali::Property::Array *)jarg1;
15049   {
15050     try {
15051       (arg1)->Clear();
15052     } catch (std::out_of_range& e) {
15053       {
15054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15055       };
15056     } catch (std::exception& e) {
15057       {
15058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15059       };
15060     } catch (Dali::DaliException e) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15063       };
15064     } catch (...) {
15065       {
15066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15067       };
15068     }
15069   }
15070
15071 }
15072
15073
15074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15075   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15076   Dali::Property::Array::SizeType arg2 ;
15077
15078   arg1 = (Dali::Property::Array *)jarg1;
15079   arg2 = (Dali::Property::Array::SizeType)jarg2;
15080   {
15081     try {
15082       (arg1)->Reserve(arg2);
15083     } catch (std::out_of_range& e) {
15084       {
15085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15086       };
15087     } catch (std::exception& e) {
15088       {
15089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15090       };
15091     } catch (Dali::DaliException e) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15094       };
15095     } catch (...) {
15096       {
15097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15098       };
15099     }
15100   }
15101
15102 }
15103
15104
15105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15106   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15107   Dali::Property::Array::SizeType arg2 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   arg2 = (Dali::Property::Array::SizeType)jarg2;
15111   {
15112     try {
15113       (arg1)->Resize(arg2);
15114     } catch (std::out_of_range& e) {
15115       {
15116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15117       };
15118     } catch (std::exception& e) {
15119       {
15120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15121       };
15122     } catch (Dali::DaliException e) {
15123       {
15124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15125       };
15126     } catch (...) {
15127       {
15128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15129       };
15130     }
15131   }
15132
15133 }
15134
15135
15136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15137   unsigned long jresult ;
15138   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15139   Dali::Property::Array::SizeType result;
15140
15141   arg1 = (Dali::Property::Array *)jarg1;
15142   {
15143     try {
15144       result = (arg1)->Capacity();
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (Dali::DaliException e) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15160       };
15161     }
15162   }
15163
15164   jresult = (unsigned long)result;
15165   return jresult;
15166 }
15167
15168
15169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15170   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15171   Dali::Property::Value *arg2 = 0 ;
15172
15173   arg1 = (Dali::Property::Array *)jarg1;
15174   arg2 = (Dali::Property::Value *)jarg2;
15175   if (!arg2) {
15176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15177     return ;
15178   }
15179   {
15180     try {
15181       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15182     } catch (std::out_of_range& e) {
15183       {
15184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15185       };
15186     } catch (std::exception& e) {
15187       {
15188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15189       };
15190     } catch (Dali::DaliException e) {
15191       {
15192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15193       };
15194     } catch (...) {
15195       {
15196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15197       };
15198     }
15199   }
15200
15201 }
15202
15203
15204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15205   void * jresult ;
15206   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15207   Dali::Property::Value *arg2 = 0 ;
15208   Dali::Property::Array *result = 0 ;
15209
15210   arg1 = (Dali::Property::Array *)jarg1;
15211   arg2 = (Dali::Property::Value *)jarg2;
15212   if (!arg2) {
15213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15214     return 0;
15215   }
15216   {
15217     try {
15218       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15219     } catch (std::out_of_range& e) {
15220       {
15221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15222       };
15223     } catch (std::exception& e) {
15224       {
15225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15226       };
15227     } catch (Dali::DaliException e) {
15228       {
15229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15230       };
15231     } catch (...) {
15232       {
15233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15234       };
15235     }
15236   }
15237
15238   jresult = (void *)result;
15239   return jresult;
15240 }
15241
15242
15243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15244   void * jresult ;
15245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15246   Dali::Property::Array::SizeType arg2 ;
15247   Dali::Property::Value *result = 0 ;
15248
15249   arg1 = (Dali::Property::Array *)jarg1;
15250   arg2 = (Dali::Property::Array::SizeType)jarg2;
15251   {
15252     try {
15253       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15254     } catch (std::out_of_range& e) {
15255       {
15256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (std::exception& e) {
15259       {
15260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (Dali::DaliException e) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15265       };
15266     } catch (...) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15269       };
15270     }
15271   }
15272
15273   jresult = (void *)result;
15274   return jresult;
15275 }
15276
15277
15278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15279   void * jresult ;
15280   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15281   Dali::Property::Array::SizeType arg2 ;
15282   Dali::Property::Value *result = 0 ;
15283
15284   arg1 = (Dali::Property::Array *)jarg1;
15285   arg2 = (Dali::Property::Array::SizeType)jarg2;
15286   {
15287     try {
15288       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15289     } catch (std::out_of_range& e) {
15290       {
15291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (std::exception& e) {
15294       {
15295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (Dali::DaliException e) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15300       };
15301     } catch (...) {
15302       {
15303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15304       };
15305     }
15306   }
15307
15308   jresult = (void *)result;
15309   return jresult;
15310 }
15311
15312
15313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15314   void * jresult ;
15315   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15316   Dali::Property::Array *arg2 = 0 ;
15317   Dali::Property::Array *result = 0 ;
15318
15319   arg1 = (Dali::Property::Array *)jarg1;
15320   arg2 = (Dali::Property::Array *)jarg2;
15321   if (!arg2) {
15322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15323     return 0;
15324   }
15325   {
15326     try {
15327       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15328     } catch (std::out_of_range& e) {
15329       {
15330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (std::exception& e) {
15333       {
15334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15335       };
15336     } catch (Dali::DaliException e) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15343       };
15344     }
15345   }
15346
15347   jresult = (void *)result;
15348   return jresult;
15349 }
15350
15351
15352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15353   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15354   enum Dali::Property::Key::Type arg2 ;
15355
15356   arg1 = (Dali::Property::Key *)jarg1;
15357   arg2 = (enum Dali::Property::Key::Type)jarg2;
15358   if (arg1) (arg1)->type = arg2;
15359 }
15360
15361
15362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15363   int jresult ;
15364   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15365   enum Dali::Property::Key::Type result;
15366
15367   arg1 = (Dali::Property::Key *)jarg1;
15368   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15369   jresult = (int)result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15375   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15376   Dali::Property::Index arg2 ;
15377
15378   arg1 = (Dali::Property::Key *)jarg1;
15379   arg2 = (Dali::Property::Index)jarg2;
15380   if (arg1) (arg1)->indexKey = arg2;
15381 }
15382
15383
15384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15385   int jresult ;
15386   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15387   Dali::Property::Index result;
15388
15389   arg1 = (Dali::Property::Key *)jarg1;
15390   result = (Dali::Property::Index) ((arg1)->indexKey);
15391   jresult = result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   std::string *arg2 = 0 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   if (!jarg2) {
15402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15403     return ;
15404   }
15405   std::string arg2_str(jarg2);
15406   arg2 = &arg2_str;
15407   if (arg1) (arg1)->stringKey = *arg2;
15408
15409   //argout typemap for const std::string&
15410
15411 }
15412
15413
15414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15415   char * jresult ;
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   std::string *result = 0 ;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   result = (std::string *) & ((arg1)->stringKey);
15421   jresult = SWIG_csharp_string_callback(result->c_str());
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15427   void * jresult ;
15428   std::string *arg1 = 0 ;
15429   Dali::Property::Key *result = 0 ;
15430
15431   if (!jarg1) {
15432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15433     return 0;
15434   }
15435   std::string arg1_str(jarg1);
15436   arg1 = &arg1_str;
15437   {
15438     try {
15439       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15440     } catch (std::out_of_range& e) {
15441       {
15442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (std::exception& e) {
15445       {
15446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15447       };
15448     } catch (Dali::DaliException e) {
15449       {
15450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15451       };
15452     } catch (...) {
15453       {
15454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15455       };
15456     }
15457   }
15458
15459   jresult = (void *)result;
15460
15461   //argout typemap for const std::string&
15462
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15468   void * jresult ;
15469   Dali::Property::Index arg1 ;
15470   Dali::Property::Key *result = 0 ;
15471
15472   arg1 = (Dali::Property::Index)jarg1;
15473   {
15474     try {
15475       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15476     } catch (std::out_of_range& e) {
15477       {
15478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15479       };
15480     } catch (std::exception& e) {
15481       {
15482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15483       };
15484     } catch (Dali::DaliException e) {
15485       {
15486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15487       };
15488     } catch (...) {
15489       {
15490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15491       };
15492     }
15493   }
15494
15495   jresult = (void *)result;
15496   return jresult;
15497 }
15498
15499
15500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15501   unsigned int jresult ;
15502   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15503   std::string *arg2 = 0 ;
15504   bool result;
15505
15506   arg1 = (Dali::Property::Key *)jarg1;
15507   if (!jarg2) {
15508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15509     return 0;
15510   }
15511   std::string arg2_str(jarg2);
15512   arg2 = &arg2_str;
15513   {
15514     try {
15515       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15516     } catch (std::out_of_range& e) {
15517       {
15518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (std::exception& e) {
15521       {
15522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (Dali::DaliException e) {
15525       {
15526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15527       };
15528     } catch (...) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15531       };
15532     }
15533   }
15534
15535   jresult = result;
15536
15537   //argout typemap for const std::string&
15538
15539   return jresult;
15540 }
15541
15542
15543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15544   unsigned int jresult ;
15545   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15546   Dali::Property::Index arg2 ;
15547   bool result;
15548
15549   arg1 = (Dali::Property::Key *)jarg1;
15550   arg2 = (Dali::Property::Index)jarg2;
15551   {
15552     try {
15553       result = (bool)(arg1)->operator ==(arg2);
15554     } catch (std::out_of_range& e) {
15555       {
15556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (std::exception& e) {
15559       {
15560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15561       };
15562     } catch (Dali::DaliException e) {
15563       {
15564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15565       };
15566     } catch (...) {
15567       {
15568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15569       };
15570     }
15571   }
15572
15573   jresult = result;
15574   return jresult;
15575 }
15576
15577
15578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15579   unsigned int jresult ;
15580   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15581   Dali::Property::Key *arg2 = 0 ;
15582   bool result;
15583
15584   arg1 = (Dali::Property::Key *)jarg1;
15585   arg2 = (Dali::Property::Key *)jarg2;
15586   if (!arg2) {
15587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15588     return 0;
15589   }
15590   {
15591     try {
15592       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15593     } catch (std::out_of_range& e) {
15594       {
15595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (std::exception& e) {
15598       {
15599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15600       };
15601     } catch (Dali::DaliException e) {
15602       {
15603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15604       };
15605     } catch (...) {
15606       {
15607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15608       };
15609     }
15610   }
15611
15612   jresult = result;
15613   return jresult;
15614 }
15615
15616
15617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15618   unsigned int jresult ;
15619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15620   std::string *arg2 = 0 ;
15621   bool result;
15622
15623   arg1 = (Dali::Property::Key *)jarg1;
15624   if (!jarg2) {
15625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15626     return 0;
15627   }
15628   std::string arg2_str(jarg2);
15629   arg2 = &arg2_str;
15630   {
15631     try {
15632       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15633     } catch (std::out_of_range& e) {
15634       {
15635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15636       };
15637     } catch (std::exception& e) {
15638       {
15639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (Dali::DaliException e) {
15642       {
15643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15644       };
15645     } catch (...) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15648       };
15649     }
15650   }
15651
15652   jresult = result;
15653
15654   //argout typemap for const std::string&
15655
15656   return jresult;
15657 }
15658
15659
15660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15661   unsigned int jresult ;
15662   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15663   Dali::Property::Index arg2 ;
15664   bool result;
15665
15666   arg1 = (Dali::Property::Key *)jarg1;
15667   arg2 = (Dali::Property::Index)jarg2;
15668   {
15669     try {
15670       result = (bool)(arg1)->operator !=(arg2);
15671     } catch (std::out_of_range& e) {
15672       {
15673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (std::exception& e) {
15676       {
15677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (Dali::DaliException e) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15682       };
15683     } catch (...) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15686       };
15687     }
15688   }
15689
15690   jresult = result;
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15696   unsigned int jresult ;
15697   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15698   Dali::Property::Key *arg2 = 0 ;
15699   bool result;
15700
15701   arg1 = (Dali::Property::Key *)jarg1;
15702   arg2 = (Dali::Property::Key *)jarg2;
15703   if (!arg2) {
15704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15705     return 0;
15706   }
15707   {
15708     try {
15709       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (Dali::DaliException e) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15721       };
15722     } catch (...) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15725       };
15726     }
15727   }
15728
15729   jresult = result;
15730   return jresult;
15731 }
15732
15733
15734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15735   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15736
15737   arg1 = (Dali::Property::Key *)jarg1;
15738   {
15739     try {
15740       delete arg1;
15741     } catch (std::out_of_range& e) {
15742       {
15743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15744       };
15745     } catch (std::exception& e) {
15746       {
15747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15748       };
15749     } catch (Dali::DaliException e) {
15750       {
15751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15756       };
15757     }
15758   }
15759
15760 }
15761
15762
15763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15764   void * jresult ;
15765   Dali::Property::Map *result = 0 ;
15766
15767   {
15768     try {
15769       result = (Dali::Property::Map *)new Dali::Property::Map();
15770     } catch (std::out_of_range& e) {
15771       {
15772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15773       };
15774     } catch (std::exception& e) {
15775       {
15776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (Dali::DaliException e) {
15779       {
15780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788
15789   jresult = (void *)result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15795   void * jresult ;
15796   Dali::Property::Map *arg1 = 0 ;
15797   Dali::Property::Map *result = 0 ;
15798
15799   arg1 = (Dali::Property::Map *)jarg1;
15800   if (!arg1) {
15801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15802     return 0;
15803   }
15804   {
15805     try {
15806       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15807     } catch (std::out_of_range& e) {
15808       {
15809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (std::exception& e) {
15812       {
15813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (Dali::DaliException e) {
15816       {
15817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15822       };
15823     }
15824   }
15825
15826   jresult = (void *)result;
15827   return jresult;
15828 }
15829
15830
15831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15832   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15833
15834   arg1 = (Dali::Property::Map *)jarg1;
15835   {
15836     try {
15837       delete arg1;
15838     } catch (std::out_of_range& e) {
15839       {
15840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15841       };
15842     } catch (std::exception& e) {
15843       {
15844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15845       };
15846     } catch (Dali::DaliException e) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15849       };
15850     } catch (...) {
15851       {
15852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15853       };
15854     }
15855   }
15856
15857 }
15858
15859
15860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15861   unsigned long jresult ;
15862   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15863   Dali::Property::Map::SizeType result;
15864
15865   arg1 = (Dali::Property::Map *)jarg1;
15866   {
15867     try {
15868       result = ((Dali::Property::Map const *)arg1)->Count();
15869     } catch (std::out_of_range& e) {
15870       {
15871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15872       };
15873     } catch (std::exception& e) {
15874       {
15875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15876       };
15877     } catch (Dali::DaliException e) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15884       };
15885     }
15886   }
15887
15888   jresult = (unsigned long)result;
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15894   unsigned int jresult ;
15895   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15896   bool result;
15897
15898   arg1 = (Dali::Property::Map *)jarg1;
15899   {
15900     try {
15901       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (Dali::DaliException e) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15913       };
15914     } catch (...) {
15915       {
15916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15917       };
15918     }
15919   }
15920
15921   jresult = result;
15922   return jresult;
15923 }
15924
15925
15926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15927   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15928   char *arg2 = (char *) 0 ;
15929   Dali::Property::Value *arg3 = 0 ;
15930
15931   arg1 = (Dali::Property::Map *)jarg1;
15932   arg2 = (char *)jarg2;
15933   arg3 = (Dali::Property::Value *)jarg3;
15934   if (!arg3) {
15935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15936     return ;
15937   }
15938   {
15939     try {
15940       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15941     } catch (std::out_of_range& e) {
15942       {
15943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15944       };
15945     } catch (std::exception& e) {
15946       {
15947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15948       };
15949     } catch (Dali::DaliException e) {
15950       {
15951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15952       };
15953     } catch (...) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15956       };
15957     }
15958   }
15959
15960 }
15961
15962
15963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15964   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15965   Dali::Property::Index arg2 ;
15966   Dali::Property::Value *arg3 = 0 ;
15967
15968   arg1 = (Dali::Property::Map *)jarg1;
15969   arg2 = (Dali::Property::Index)jarg2;
15970   arg3 = (Dali::Property::Value *)jarg3;
15971   if (!arg3) {
15972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15973     return ;
15974   }
15975   {
15976     try {
15977       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15978     } catch (std::out_of_range& e) {
15979       {
15980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15981       };
15982     } catch (std::exception& e) {
15983       {
15984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15985       };
15986     } catch (Dali::DaliException e) {
15987       {
15988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15989       };
15990     } catch (...) {
15991       {
15992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15993       };
15994     }
15995   }
15996
15997 }
15998
15999
16000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16001   void * jresult ;
16002   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16003   char *arg2 = (char *) 0 ;
16004   Dali::Property::Value *arg3 = 0 ;
16005   Dali::Property::Map *result = 0 ;
16006
16007   arg1 = (Dali::Property::Map *)jarg1;
16008   arg2 = (char *)jarg2;
16009   arg3 = (Dali::Property::Value *)jarg3;
16010   if (!arg3) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16012     return 0;
16013   }
16014   {
16015     try {
16016       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16024       };
16025     } catch (Dali::DaliException e) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16028       };
16029     } catch (...) {
16030       {
16031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16032       };
16033     }
16034   }
16035
16036   jresult = (void *)result;
16037   return jresult;
16038 }
16039
16040
16041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16042   void * jresult ;
16043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16044   Dali::Property::Index arg2 ;
16045   Dali::Property::Value *arg3 = 0 ;
16046   Dali::Property::Map *result = 0 ;
16047
16048   arg1 = (Dali::Property::Map *)jarg1;
16049   arg2 = (Dali::Property::Index)jarg2;
16050   arg3 = (Dali::Property::Value *)jarg3;
16051   if (!arg3) {
16052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16053     return 0;
16054   }
16055   {
16056     try {
16057       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16058     } catch (std::out_of_range& e) {
16059       {
16060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16061       };
16062     } catch (std::exception& e) {
16063       {
16064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (Dali::DaliException e) {
16067       {
16068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16069       };
16070     } catch (...) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16073       };
16074     }
16075   }
16076
16077   jresult = (void *)result;
16078   return jresult;
16079 }
16080
16081
16082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16083   void * jresult ;
16084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16085   Dali::Property::Map::SizeType arg2 ;
16086   Dali::Property::Value *result = 0 ;
16087
16088   arg1 = (Dali::Property::Map *)jarg1;
16089   arg2 = (Dali::Property::Map::SizeType)jarg2;
16090   {
16091     try {
16092       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16093     } catch (std::out_of_range& e) {
16094       {
16095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16096       };
16097     } catch (std::exception& e) {
16098       {
16099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16100       };
16101     } catch (Dali::DaliException e) {
16102       {
16103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16104       };
16105     } catch (...) {
16106       {
16107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16108       };
16109     }
16110   }
16111
16112   jresult = (void *)result;
16113   return jresult;
16114 }
16115
16116
16117 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16118   char * jresult ;
16119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16120   Dali::Property::Map::SizeType arg2 ;
16121   std::string *result = 0 ;
16122
16123   arg1 = (Dali::Property::Map *)jarg1;
16124   arg2 = (Dali::Property::Map::SizeType)jarg2;
16125   {
16126     try {
16127       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16128     } catch (std::out_of_range& e) {
16129       {
16130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16131       };
16132     } catch (std::exception& e) {
16133       {
16134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16135       };
16136     } catch (Dali::DaliException e) {
16137       {
16138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16139       };
16140     } catch (...) {
16141       {
16142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16143       };
16144     }
16145   }
16146
16147   jresult = SWIG_csharp_string_callback(result->c_str());
16148   return jresult;
16149 }
16150
16151
16152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16153   void * jresult ;
16154   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16155   Dali::Property::Map::SizeType arg2 ;
16156   SwigValueWrapper< Dali::Property::Key > result;
16157
16158   arg1 = (Dali::Property::Map *)jarg1;
16159   arg2 = (Dali::Property::Map::SizeType)jarg2;
16160   {
16161     try {
16162       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16163     } catch (std::out_of_range& e) {
16164       {
16165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (std::exception& e) {
16168       {
16169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (Dali::DaliException e) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16174       };
16175     } catch (...) {
16176       {
16177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16178       };
16179     }
16180   }
16181
16182   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16183   return jresult;
16184 }
16185
16186
16187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16188   void * jresult ;
16189   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16190   Dali::Property::Map::SizeType arg2 ;
16191   StringValuePair *result = 0 ;
16192
16193   arg1 = (Dali::Property::Map *)jarg1;
16194   arg2 = (Dali::Property::Map::SizeType)jarg2;
16195   {
16196     try {
16197       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16198     } catch (std::out_of_range& e) {
16199       {
16200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (std::exception& e) {
16203       {
16204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (Dali::DaliException e) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16209       };
16210     } catch (...) {
16211       {
16212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16213       };
16214     }
16215   }
16216
16217   jresult = (void *)result;
16218   return jresult;
16219 }
16220
16221
16222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16223   void * jresult ;
16224   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16225   char *arg2 = (char *) 0 ;
16226   Dali::Property::Value *result = 0 ;
16227
16228   arg1 = (Dali::Property::Map *)jarg1;
16229   arg2 = (char *)jarg2;
16230   {
16231     try {
16232       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16233     } catch (std::out_of_range& e) {
16234       {
16235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16236       };
16237     } catch (std::exception& e) {
16238       {
16239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16240       };
16241     } catch (Dali::DaliException e) {
16242       {
16243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16244       };
16245     } catch (...) {
16246       {
16247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16248       };
16249     }
16250   }
16251
16252   jresult = (void *)result;
16253   return jresult;
16254 }
16255
16256
16257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16258   void * jresult ;
16259   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16260   Dali::Property::Index arg2 ;
16261   Dali::Property::Value *result = 0 ;
16262
16263   arg1 = (Dali::Property::Map *)jarg1;
16264   arg2 = (Dali::Property::Index)jarg2;
16265   {
16266     try {
16267       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16268     } catch (std::out_of_range& e) {
16269       {
16270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16271       };
16272     } catch (std::exception& e) {
16273       {
16274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16275       };
16276     } catch (Dali::DaliException e) {
16277       {
16278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16279       };
16280     } catch (...) {
16281       {
16282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16283       };
16284     }
16285   }
16286
16287   jresult = (void *)result;
16288   return jresult;
16289 }
16290
16291
16292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16293   void * jresult ;
16294   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16295   Dali::Property::Index arg2 ;
16296   std::string *arg3 = 0 ;
16297   Dali::Property::Value *result = 0 ;
16298
16299   arg1 = (Dali::Property::Map *)jarg1;
16300   arg2 = (Dali::Property::Index)jarg2;
16301   if (!jarg3) {
16302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16303     return 0;
16304   }
16305   std::string arg3_str(jarg3);
16306   arg3 = &arg3_str;
16307   {
16308     try {
16309       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16310     } catch (std::out_of_range& e) {
16311       {
16312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (std::exception& e) {
16315       {
16316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16317       };
16318     } catch (Dali::DaliException e) {
16319       {
16320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16321       };
16322     } catch (...) {
16323       {
16324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16325       };
16326     }
16327   }
16328
16329   jresult = (void *)result;
16330
16331   //argout typemap for const std::string&
16332
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   std::string *arg2 = 0 ;
16341   Dali::Property::Type arg3 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   if (!jarg2) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg2_str(jarg2);
16350   arg2 = &arg2_str;
16351   arg3 = (Dali::Property::Type)jarg3;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   Dali::Property::Index arg2 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   arg2 = (Dali::Property::Index)jarg2;
16391   arg3 = (Dali::Property::Type)jarg3;
16392   {
16393     try {
16394       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16395     } catch (std::out_of_range& e) {
16396       {
16397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16398       };
16399     } catch (std::exception& e) {
16400       {
16401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (Dali::DaliException e) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16406       };
16407     } catch (...) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16410       };
16411     }
16412   }
16413
16414   jresult = (void *)result;
16415   return jresult;
16416 }
16417
16418
16419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16420   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16421
16422   arg1 = (Dali::Property::Map *)jarg1;
16423   {
16424     try {
16425       (arg1)->Clear();
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16433       };
16434     } catch (Dali::DaliException e) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16437       };
16438     } catch (...) {
16439       {
16440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16441       };
16442     }
16443   }
16444
16445 }
16446
16447
16448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16449   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16450   Dali::Property::Map *arg2 = 0 ;
16451
16452   arg1 = (Dali::Property::Map *)jarg1;
16453   arg2 = (Dali::Property::Map *)jarg2;
16454   if (!arg2) {
16455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16456     return ;
16457   }
16458   {
16459     try {
16460       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16461     } catch (std::out_of_range& e) {
16462       {
16463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16464       };
16465     } catch (std::exception& e) {
16466       {
16467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16468       };
16469     } catch (Dali::DaliException e) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16472       };
16473     } catch (...) {
16474       {
16475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16476       };
16477     }
16478   }
16479
16480 }
16481
16482
16483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16484   void * jresult ;
16485   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16486   std::string *arg2 = 0 ;
16487   Dali::Property::Value *result = 0 ;
16488
16489   arg1 = (Dali::Property::Map *)jarg1;
16490   if (!jarg2) {
16491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16492     return 0;
16493   }
16494   std::string arg2_str(jarg2);
16495   arg2 = &arg2_str;
16496   {
16497     try {
16498       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16499     } catch (std::out_of_range& e) {
16500       {
16501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16502       };
16503     } catch (std::exception& e) {
16504       {
16505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16506       };
16507     } catch (Dali::DaliException e) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16510       };
16511     } catch (...) {
16512       {
16513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16514       };
16515     }
16516   }
16517
16518   jresult = (void *)result;
16519
16520   //argout typemap for const std::string&
16521
16522   return jresult;
16523 }
16524
16525
16526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16527   void * jresult ;
16528   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16529   Dali::Property::Index arg2 ;
16530   Dali::Property::Value *result = 0 ;
16531
16532   arg1 = (Dali::Property::Map *)jarg1;
16533   arg2 = (Dali::Property::Index)jarg2;
16534   {
16535     try {
16536       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16537     } catch (std::out_of_range& e) {
16538       {
16539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (std::exception& e) {
16542       {
16543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (Dali::DaliException e) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16548       };
16549     } catch (...) {
16550       {
16551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16552       };
16553     }
16554   }
16555
16556   jresult = (void *)result;
16557   return jresult;
16558 }
16559
16560
16561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16562   void * jresult ;
16563   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16564   Dali::Property::Map *arg2 = 0 ;
16565   Dali::Property::Map *result = 0 ;
16566
16567   arg1 = (Dali::Property::Map *)jarg1;
16568   arg2 = (Dali::Property::Map *)jarg2;
16569   if (!arg2) {
16570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16571     return 0;
16572   }
16573   {
16574     try {
16575       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16576     } catch (std::out_of_range& e) {
16577       {
16578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (std::exception& e) {
16581       {
16582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (Dali::DaliException e) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594
16595   jresult = (void *)result;
16596   return jresult;
16597 }
16598
16599
16600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16601
16602   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16603
16604   if (!jarg2) {
16605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16606     return;
16607   }
16608   std::string arg2_str(jarg2);
16609   std::string* arg2 = &arg2_str;
16610
16611   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16612
16613   {
16614     try {
16615       arg1->operator[]((std::string const &)*arg2) = *arg3;
16616     } catch (std::out_of_range& e) {
16617       {
16618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16619       };
16620     } catch (std::exception& e) {
16621       {
16622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16623       };
16624     } catch (Dali::DaliException e) {
16625       {
16626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16627       };
16628     } catch (...) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16631       };
16632     }
16633   }
16634 }
16635
16636
16637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16638
16639   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16640   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16641   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16642
16643   {
16644     try {
16645       arg1->operator[](arg2) = *arg3;
16646     } catch (std::out_of_range& e) {
16647       {
16648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16649       };
16650     } catch (std::exception& e) {
16651       {
16652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16653       };
16654     } catch (Dali::DaliException e) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16657       };
16658     } catch (...) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16661       };
16662     }
16663   }
16664 }
16665
16666
16667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16668   void * jresult ;
16669   Dali::Property::Value *result = 0 ;
16670
16671   {
16672     try {
16673       result = (Dali::Property::Value *)new Dali::Property::Value();
16674     } catch (std::out_of_range& e) {
16675       {
16676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16677       };
16678     } catch (std::exception& e) {
16679       {
16680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16681       };
16682     } catch (Dali::DaliException e) {
16683       {
16684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16685       };
16686     } catch (...) {
16687       {
16688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16689       };
16690     }
16691   }
16692
16693   jresult = (void *)result;
16694   return jresult;
16695 }
16696
16697
16698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16699   void * jresult ;
16700   bool arg1 ;
16701   Dali::Property::Value *result = 0 ;
16702
16703   arg1 = jarg1 ? true : false;
16704   {
16705     try {
16706       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16707     } catch (std::out_of_range& e) {
16708       {
16709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16710       };
16711     } catch (std::exception& e) {
16712       {
16713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16714       };
16715     } catch (Dali::DaliException e) {
16716       {
16717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16718       };
16719     } catch (...) {
16720       {
16721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16722       };
16723     }
16724   }
16725
16726   jresult = (void *)result;
16727   return jresult;
16728 }
16729
16730
16731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16732   void * jresult ;
16733   int arg1 ;
16734   Dali::Property::Value *result = 0 ;
16735
16736   arg1 = (int)jarg1;
16737   {
16738     try {
16739       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16740     } catch (std::out_of_range& e) {
16741       {
16742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16743       };
16744     } catch (std::exception& e) {
16745       {
16746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16747       };
16748     } catch (Dali::DaliException e) {
16749       {
16750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16751       };
16752     } catch (...) {
16753       {
16754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16755       };
16756     }
16757   }
16758
16759   jresult = (void *)result;
16760   return jresult;
16761 }
16762
16763
16764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16765   void * jresult ;
16766   float arg1 ;
16767   Dali::Property::Value *result = 0 ;
16768
16769   arg1 = (float)jarg1;
16770   {
16771     try {
16772       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16773     } catch (std::out_of_range& e) {
16774       {
16775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16776       };
16777     } catch (std::exception& e) {
16778       {
16779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16780       };
16781     } catch (Dali::DaliException e) {
16782       {
16783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16784       };
16785     } catch (...) {
16786       {
16787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16788       };
16789     }
16790   }
16791
16792   jresult = (void *)result;
16793   return jresult;
16794 }
16795
16796
16797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16798   void * jresult ;
16799   Dali::Vector2 *arg1 = 0 ;
16800   Dali::Property::Value *result = 0 ;
16801
16802   arg1 = (Dali::Vector2 *)jarg1;
16803   if (!arg1) {
16804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16805     return 0;
16806   }
16807   {
16808     try {
16809       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16810     } catch (std::out_of_range& e) {
16811       {
16812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16813       };
16814     } catch (std::exception& e) {
16815       {
16816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16817       };
16818     } catch (Dali::DaliException e) {
16819       {
16820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16821       };
16822     } catch (...) {
16823       {
16824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16825       };
16826     }
16827   }
16828
16829   jresult = (void *)result;
16830   return jresult;
16831 }
16832
16833
16834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16835   void * jresult ;
16836   Dali::Vector3 *arg1 = 0 ;
16837   Dali::Property::Value *result = 0 ;
16838
16839   arg1 = (Dali::Vector3 *)jarg1;
16840   if (!arg1) {
16841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16842     return 0;
16843   }
16844   {
16845     try {
16846       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16847     } catch (std::out_of_range& e) {
16848       {
16849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16850       };
16851     } catch (std::exception& e) {
16852       {
16853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16854       };
16855     } catch (Dali::DaliException e) {
16856       {
16857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16858       };
16859     } catch (...) {
16860       {
16861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16862       };
16863     }
16864   }
16865
16866   jresult = (void *)result;
16867   return jresult;
16868 }
16869
16870
16871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16872   void * jresult ;
16873   Dali::Vector4 *arg1 = 0 ;
16874   Dali::Property::Value *result = 0 ;
16875
16876   arg1 = (Dali::Vector4 *)jarg1;
16877   if (!arg1) {
16878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16879     return 0;
16880   }
16881   {
16882     try {
16883       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16884     } catch (std::out_of_range& e) {
16885       {
16886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16887       };
16888     } catch (std::exception& e) {
16889       {
16890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16891       };
16892     } catch (Dali::DaliException e) {
16893       {
16894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16895       };
16896     } catch (...) {
16897       {
16898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16899       };
16900     }
16901   }
16902
16903   jresult = (void *)result;
16904   return jresult;
16905 }
16906
16907
16908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16909   void * jresult ;
16910   Dali::Matrix3 *arg1 = 0 ;
16911   Dali::Property::Value *result = 0 ;
16912
16913   arg1 = (Dali::Matrix3 *)jarg1;
16914   if (!arg1) {
16915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16916     return 0;
16917   }
16918   {
16919     try {
16920       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16921     } catch (std::out_of_range& e) {
16922       {
16923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (std::exception& e) {
16926       {
16927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16928       };
16929     } catch (Dali::DaliException e) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16932       };
16933     } catch (...) {
16934       {
16935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16936       };
16937     }
16938   }
16939
16940   jresult = (void *)result;
16941   return jresult;
16942 }
16943
16944
16945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16946   void * jresult ;
16947   Dali::Matrix *arg1 = 0 ;
16948   Dali::Property::Value *result = 0 ;
16949
16950   arg1 = (Dali::Matrix *)jarg1;
16951   if (!arg1) {
16952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16953     return 0;
16954   }
16955   {
16956     try {
16957       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16958     } catch (std::out_of_range& e) {
16959       {
16960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (std::exception& e) {
16963       {
16964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16965       };
16966     } catch (Dali::DaliException e) {
16967       {
16968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16969       };
16970     } catch (...) {
16971       {
16972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16973       };
16974     }
16975   }
16976
16977   jresult = (void *)result;
16978   return jresult;
16979 }
16980
16981
16982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16983   void * jresult ;
16984   Dali::Rect< int > *arg1 = 0 ;
16985   Dali::Property::Value *result = 0 ;
16986
16987   arg1 = (Dali::Rect< int > *)jarg1;
16988   if (!arg1) {
16989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16990     return 0;
16991   }
16992   {
16993     try {
16994       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16995     } catch (std::out_of_range& e) {
16996       {
16997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (std::exception& e) {
17000       {
17001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17002       };
17003     } catch (Dali::DaliException e) {
17004       {
17005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17006       };
17007     } catch (...) {
17008       {
17009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17010       };
17011     }
17012   }
17013
17014   jresult = (void *)result;
17015   return jresult;
17016 }
17017
17018
17019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17020   void * jresult ;
17021   Dali::AngleAxis *arg1 = 0 ;
17022   Dali::Property::Value *result = 0 ;
17023
17024   arg1 = (Dali::AngleAxis *)jarg1;
17025   if (!arg1) {
17026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17027     return 0;
17028   }
17029   {
17030     try {
17031       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17032     } catch (std::out_of_range& e) {
17033       {
17034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17035       };
17036     } catch (std::exception& e) {
17037       {
17038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17039       };
17040     } catch (Dali::DaliException e) {
17041       {
17042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17043       };
17044     } catch (...) {
17045       {
17046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17047       };
17048     }
17049   }
17050
17051   jresult = (void *)result;
17052   return jresult;
17053 }
17054
17055
17056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17057   void * jresult ;
17058   Dali::Quaternion *arg1 = 0 ;
17059   Dali::Property::Value *result = 0 ;
17060
17061   arg1 = (Dali::Quaternion *)jarg1;
17062   if (!arg1) {
17063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17064     return 0;
17065   }
17066   {
17067     try {
17068       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17069     } catch (std::out_of_range& e) {
17070       {
17071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (std::exception& e) {
17074       {
17075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17076       };
17077     } catch (Dali::DaliException e) {
17078       {
17079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17080       };
17081     } catch (...) {
17082       {
17083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17084       };
17085     }
17086   }
17087
17088   jresult = (void *)result;
17089   return jresult;
17090 }
17091
17092
17093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17094   void * jresult ;
17095   std::string *arg1 = 0 ;
17096   Dali::Property::Value *result = 0 ;
17097
17098   if (!jarg1) {
17099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17100     return 0;
17101   }
17102   std::string arg1_str(jarg1);
17103   arg1 = &arg1_str;
17104   {
17105     try {
17106       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17107     } catch (std::out_of_range& e) {
17108       {
17109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17110       };
17111     } catch (std::exception& e) {
17112       {
17113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17114       };
17115     } catch (Dali::DaliException e) {
17116       {
17117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17118       };
17119     } catch (...) {
17120       {
17121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17122       };
17123     }
17124   }
17125
17126   jresult = (void *)result;
17127
17128   //argout typemap for const std::string&
17129
17130   return jresult;
17131 }
17132
17133
17134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17135   void * jresult ;
17136   Dali::Property::Array *arg1 = 0 ;
17137   Dali::Property::Value *result = 0 ;
17138
17139   arg1 = (Dali::Property::Array *)jarg1;
17140   if (!arg1) {
17141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17142     return 0;
17143   }
17144   {
17145     try {
17146       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17147     } catch (std::out_of_range& e) {
17148       {
17149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17150       };
17151     } catch (std::exception& e) {
17152       {
17153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17154       };
17155     } catch (Dali::DaliException e) {
17156       {
17157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17158       };
17159     } catch (...) {
17160       {
17161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17162       };
17163     }
17164   }
17165
17166   jresult = (void *)result;
17167   return jresult;
17168 }
17169
17170
17171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17172   void * jresult ;
17173   Dali::Property::Map *arg1 = 0 ;
17174   Dali::Property::Value *result = 0 ;
17175
17176   arg1 = (Dali::Property::Map *)jarg1;
17177   if (!arg1) {
17178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17179     return 0;
17180   }
17181   {
17182     try {
17183       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17184     } catch (std::out_of_range& e) {
17185       {
17186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17187       };
17188     } catch (std::exception& e) {
17189       {
17190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17191       };
17192     } catch (Dali::DaliException e) {
17193       {
17194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17195       };
17196     } catch (...) {
17197       {
17198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17199       };
17200     }
17201   }
17202
17203   jresult = (void *)result;
17204   return jresult;
17205 }
17206
17207
17208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17209   void * jresult ;
17210   Extents *arg1 = 0 ;
17211   Dali::Property::Value *result = 0 ;
17212
17213   arg1 = (Extents *)jarg1;
17214   if (!arg1) {
17215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17216     return 0;
17217   }
17218   {
17219     try {
17220       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (...) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17232       };
17233     }
17234   }
17235   jresult = (void *)result;
17236   return jresult;
17237 }
17238
17239
17240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17241   void * jresult ;
17242   Dali::Property::Type arg1 ;
17243   Dali::Property::Value *result = 0 ;
17244
17245   arg1 = (Dali::Property::Type)jarg1;
17246   {
17247     try {
17248       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17249     } catch (std::out_of_range& e) {
17250       {
17251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (std::exception& e) {
17254       {
17255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17256       };
17257     } catch (Dali::DaliException e) {
17258       {
17259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17260       };
17261     } catch (...) {
17262       {
17263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17264       };
17265     }
17266   }
17267
17268   jresult = (void *)result;
17269   return jresult;
17270 }
17271
17272
17273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17274   void * jresult ;
17275   Dali::Property::Value *arg1 = 0 ;
17276   Dali::Property::Value *result = 0 ;
17277
17278   arg1 = (Dali::Property::Value *)jarg1;
17279   if (!arg1) {
17280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17281     return 0;
17282   }
17283   {
17284     try {
17285       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17286     } catch (std::out_of_range& e) {
17287       {
17288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17289       };
17290     } catch (std::exception& e) {
17291       {
17292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17293       };
17294     } catch (Dali::DaliException e) {
17295       {
17296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17297       };
17298     } catch (...) {
17299       {
17300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17301       };
17302     }
17303   }
17304
17305   jresult = (void *)result;
17306   return jresult;
17307 }
17308
17309
17310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17311   void * jresult ;
17312   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17313   Dali::Property::Value *arg2 = 0 ;
17314   Dali::Property::Value *result = 0 ;
17315
17316   arg1 = (Dali::Property::Value *)jarg1;
17317   arg2 = (Dali::Property::Value *)jarg2;
17318   if (!arg2) {
17319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17320     return 0;
17321   }
17322   {
17323     try {
17324       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17325     } catch (std::out_of_range& e) {
17326       {
17327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17328       };
17329     } catch (std::exception& e) {
17330       {
17331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17332       };
17333     } catch (Dali::DaliException e) {
17334       {
17335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17336       };
17337     } catch (...) {
17338       {
17339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17340       };
17341     }
17342   }
17343
17344   jresult = (void *)result;
17345   return jresult;
17346 }
17347
17348
17349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17350   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17351
17352   arg1 = (Dali::Property::Value *)jarg1;
17353   {
17354     try {
17355       delete arg1;
17356     } catch (std::out_of_range& e) {
17357       {
17358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17359       };
17360     } catch (std::exception& e) {
17361       {
17362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17363       };
17364     } catch (Dali::DaliException e) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17367       };
17368     } catch (...) {
17369       {
17370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17371       };
17372     }
17373   }
17374
17375 }
17376
17377
17378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17379   int jresult ;
17380   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17381   Dali::Property::Type result;
17382
17383   arg1 = (Dali::Property::Value *)jarg1;
17384   {
17385     try {
17386       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (Dali::DaliException e) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17402       };
17403     }
17404   }
17405
17406   jresult = (int)result;
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17412   unsigned int jresult ;
17413   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17414   bool *arg2 = 0 ;
17415   bool result;
17416
17417   arg1 = (Dali::Property::Value *)jarg1;
17418   arg2 = (bool *)jarg2;
17419   {
17420     try {
17421       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17422     } catch (std::out_of_range& e) {
17423       {
17424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (std::exception& e) {
17427       {
17428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17429       };
17430     } catch (Dali::DaliException e) {
17431       {
17432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17433       };
17434     } catch (...) {
17435       {
17436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17437       };
17438     }
17439   }
17440
17441   jresult = result;
17442   return jresult;
17443 }
17444
17445
17446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17447   unsigned int jresult ;
17448   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17449   float *arg2 = 0 ;
17450   bool result;
17451
17452   arg1 = (Dali::Property::Value *)jarg1;
17453   arg2 = (float *)jarg2;
17454   {
17455     try {
17456       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17457     } catch (std::out_of_range& e) {
17458       {
17459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (std::exception& e) {
17462       {
17463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17464       };
17465     } catch (Dali::DaliException e) {
17466       {
17467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17468       };
17469     } catch (...) {
17470       {
17471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17472       };
17473     }
17474   }
17475
17476   jresult = result;
17477   return jresult;
17478 }
17479
17480
17481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17482   unsigned int jresult ;
17483   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17484   int *arg2 = 0 ;
17485   bool result;
17486
17487   arg1 = (Dali::Property::Value *)jarg1;
17488   arg2 = (int *)jarg2;
17489   {
17490     try {
17491       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17492     } catch (std::out_of_range& e) {
17493       {
17494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (std::exception& e) {
17497       {
17498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17499       };
17500     } catch (Dali::DaliException e) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17503       };
17504     } catch (...) {
17505       {
17506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17507       };
17508     }
17509   }
17510
17511   jresult = result;
17512   return jresult;
17513 }
17514
17515
17516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17517   unsigned int jresult ;
17518   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17519   Dali::Rect< int > *arg2 = 0 ;
17520   bool result;
17521
17522   arg1 = (Dali::Property::Value *)jarg1;
17523   arg2 = (Dali::Rect< int > *)jarg2;
17524   if (!arg2) {
17525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17526     return 0;
17527   }
17528   {
17529     try {
17530       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17531     } catch (std::out_of_range& e) {
17532       {
17533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17534       };
17535     } catch (std::exception& e) {
17536       {
17537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17538       };
17539     } catch (Dali::DaliException e) {
17540       {
17541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17542       };
17543     } catch (...) {
17544       {
17545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17546       };
17547     }
17548   }
17549
17550   jresult = result;
17551   return jresult;
17552 }
17553
17554
17555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17556   unsigned int jresult ;
17557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17558   Dali::Vector2 *arg2 = 0 ;
17559   bool result;
17560
17561   arg1 = (Dali::Property::Value *)jarg1;
17562   arg2 = (Dali::Vector2 *)jarg2;
17563   if (!arg2) {
17564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17565     return 0;
17566   }
17567   {
17568     try {
17569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17570     } catch (std::out_of_range& e) {
17571       {
17572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (std::exception& e) {
17575       {
17576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (Dali::DaliException e) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17581       };
17582     } catch (...) {
17583       {
17584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17585       };
17586     }
17587   }
17588
17589   jresult = result;
17590   return jresult;
17591 }
17592
17593
17594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17595   unsigned int jresult ;
17596   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17597   Dali::Vector3 *arg2 = 0 ;
17598   bool result;
17599
17600   arg1 = (Dali::Property::Value *)jarg1;
17601   arg2 = (Dali::Vector3 *)jarg2;
17602   if (!arg2) {
17603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17604     return 0;
17605   }
17606   {
17607     try {
17608       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17609     } catch (std::out_of_range& e) {
17610       {
17611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (std::exception& e) {
17614       {
17615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17616       };
17617     } catch (Dali::DaliException e) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17620       };
17621     } catch (...) {
17622       {
17623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17624       };
17625     }
17626   }
17627
17628   jresult = result;
17629   return jresult;
17630 }
17631
17632
17633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17634   unsigned int jresult ;
17635   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17636   Dali::Vector4 *arg2 = 0 ;
17637   bool result;
17638
17639   arg1 = (Dali::Property::Value *)jarg1;
17640   arg2 = (Dali::Vector4 *)jarg2;
17641   if (!arg2) {
17642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17643     return 0;
17644   }
17645   {
17646     try {
17647       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17648     } catch (std::out_of_range& e) {
17649       {
17650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17651       };
17652     } catch (std::exception& e) {
17653       {
17654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (Dali::DaliException e) {
17657       {
17658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666
17667   jresult = result;
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17673   unsigned int jresult ;
17674   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17675   Dali::Matrix3 *arg2 = 0 ;
17676   bool result;
17677
17678   arg1 = (Dali::Property::Value *)jarg1;
17679   arg2 = (Dali::Matrix3 *)jarg2;
17680   if (!arg2) {
17681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17682     return 0;
17683   }
17684   {
17685     try {
17686       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17687     } catch (std::out_of_range& e) {
17688       {
17689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17690       };
17691     } catch (std::exception& e) {
17692       {
17693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17694       };
17695     } catch (Dali::DaliException e) {
17696       {
17697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17698       };
17699     } catch (...) {
17700       {
17701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17702       };
17703     }
17704   }
17705
17706   jresult = result;
17707   return jresult;
17708 }
17709
17710
17711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17712   unsigned int jresult ;
17713   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17714   Dali::Matrix *arg2 = 0 ;
17715   bool result;
17716
17717   arg1 = (Dali::Property::Value *)jarg1;
17718   arg2 = (Dali::Matrix *)jarg2;
17719   if (!arg2) {
17720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17721     return 0;
17722   }
17723   {
17724     try {
17725       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17726     } catch (std::out_of_range& e) {
17727       {
17728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17729       };
17730     } catch (std::exception& e) {
17731       {
17732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17733       };
17734     } catch (Dali::DaliException e) {
17735       {
17736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17737       };
17738     } catch (...) {
17739       {
17740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17741       };
17742     }
17743   }
17744
17745   jresult = result;
17746   return jresult;
17747 }
17748
17749
17750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17751   unsigned int jresult ;
17752   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17753   Dali::AngleAxis *arg2 = 0 ;
17754   bool result;
17755
17756   arg1 = (Dali::Property::Value *)jarg1;
17757   arg2 = (Dali::AngleAxis *)jarg2;
17758   if (!arg2) {
17759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17760     return 0;
17761   }
17762   {
17763     try {
17764       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17765     } catch (std::out_of_range& e) {
17766       {
17767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (std::exception& e) {
17770       {
17771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17772       };
17773     } catch (Dali::DaliException e) {
17774       {
17775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17776       };
17777     } catch (...) {
17778       {
17779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17780       };
17781     }
17782   }
17783
17784   jresult = result;
17785   return jresult;
17786 }
17787
17788
17789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17790   unsigned int jresult ;
17791   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17792   Dali::Quaternion *arg2 = 0 ;
17793   bool result;
17794
17795   arg1 = (Dali::Property::Value *)jarg1;
17796   arg2 = (Dali::Quaternion *)jarg2;
17797   if (!arg2) {
17798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17799     return 0;
17800   }
17801   {
17802     try {
17803       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17804     } catch (std::out_of_range& e) {
17805       {
17806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17807       };
17808     } catch (std::exception& e) {
17809       {
17810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17811       };
17812     } catch (Dali::DaliException e) {
17813       {
17814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17815       };
17816     } catch (...) {
17817       {
17818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17819       };
17820     }
17821   }
17822
17823   jresult = result;
17824   return jresult;
17825 }
17826
17827
17828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17829   unsigned int jresult ;
17830   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17831   std::string *arg2 = 0 ;
17832   bool result;
17833
17834   arg1 = (Dali::Property::Value *)jarg1;
17835
17836   //typemap in
17837   std::string temp;
17838   arg2 = &temp;
17839
17840   {
17841     try {
17842       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17843     } catch (std::out_of_range& e) {
17844       {
17845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (std::exception& e) {
17848       {
17849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17850       };
17851     } catch (Dali::DaliException e) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17854       };
17855     } catch (...) {
17856       {
17857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17858       };
17859     }
17860   }
17861
17862   jresult = result;
17863
17864   //Typemap argout in c++ file.
17865   //This will convert c++ string to c# string
17866   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17867
17868   return jresult;
17869 }
17870
17871
17872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17873   unsigned int jresult ;
17874   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17875   Dali::Property::Array *arg2 = 0 ;
17876   bool result;
17877
17878   arg1 = (Dali::Property::Value *)jarg1;
17879   arg2 = (Dali::Property::Array *)jarg2;
17880   if (!arg2) {
17881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17882     return 0;
17883   }
17884   {
17885     try {
17886       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17887     } catch (std::out_of_range& e) {
17888       {
17889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17890       };
17891     } catch (std::exception& e) {
17892       {
17893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17894       };
17895     } catch (Dali::DaliException e) {
17896       {
17897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17898       };
17899     } catch (...) {
17900       {
17901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17902       };
17903     }
17904   }
17905
17906   jresult = result;
17907   return jresult;
17908 }
17909
17910
17911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17912   unsigned int jresult ;
17913   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17914   Dali::Property::Map *arg2 = 0 ;
17915   bool result;
17916
17917   arg1 = (Dali::Property::Value *)jarg1;
17918   arg2 = (Dali::Property::Map *)jarg2;
17919   if (!arg2) {
17920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17921     return 0;
17922   }
17923   {
17924     try {
17925       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17926     } catch (std::out_of_range& e) {
17927       {
17928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17929       };
17930     } catch (std::exception& e) {
17931       {
17932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17933       };
17934     } catch (Dali::DaliException e) {
17935       {
17936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17937       };
17938     } catch (...) {
17939       {
17940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17941       };
17942     }
17943   }
17944
17945   jresult = result;
17946   return jresult;
17947 }
17948
17949
17950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17951   unsigned int jresult ;
17952   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17953   Extents *arg2 = 0 ;
17954   bool result;
17955
17956   arg1 = (Dali::Property::Value *)jarg1;
17957   arg2 = (Extents *)jarg2;
17958   if (!arg2) {
17959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17960     return 0;
17961   }
17962   {
17963     try {
17964       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17965     } catch (std::out_of_range& e) {
17966       {
17967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (std::exception& e) {
17970       {
17971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (...) {
17974       {
17975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17976       };
17977     }
17978   }
17979   jresult = result;
17980   return jresult;
17981 }
17982
17983
17984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17985   void * jresult ;
17986   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17987   Dali::Property::Array *result = 0 ;
17988
17989   arg1 = (Dali::Property::Value *)jarg1;
17990   {
17991     try {
17992       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17993     } catch (std::out_of_range& e) {
17994       {
17995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17996       };
17997     } catch (std::exception& e) {
17998       {
17999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18000       };
18001     } catch (Dali::DaliException e) {
18002       {
18003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18004       };
18005     } catch (...) {
18006       {
18007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18008       };
18009     }
18010   }
18011
18012   jresult = (void *)result;
18013   return jresult;
18014 }
18015
18016
18017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18018   void * jresult ;
18019   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18020   Dali::Property::Map *result = 0 ;
18021
18022   arg1 = (Dali::Property::Value *)jarg1;
18023   {
18024     try {
18025       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18026     } catch (std::out_of_range& e) {
18027       {
18028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (std::exception& e) {
18031       {
18032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18033       };
18034     } catch (Dali::DaliException e) {
18035       {
18036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18037       };
18038     } catch (...) {
18039       {
18040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18041       };
18042     }
18043   }
18044
18045   jresult = (void *)result;
18046   return jresult;
18047 }
18048
18049
18050 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18051   char * jresult ;
18052   Dali::Property::Type arg1 ;
18053   char *result = 0 ;
18054
18055   arg1 = (Dali::Property::Type)jarg1;
18056   {
18057     try {
18058       result = (char *)Dali::PropertyTypes::GetName(arg1);
18059     } catch (std::out_of_range& e) {
18060       {
18061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (std::exception& e) {
18064       {
18065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18066       };
18067     } catch (Dali::DaliException e) {
18068       {
18069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18070       };
18071     } catch (...) {
18072       {
18073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18074       };
18075     }
18076   }
18077
18078   jresult = SWIG_csharp_string_callback((const char *)result);
18079   return jresult;
18080 }
18081
18082
18083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18084   unsigned int jresult ;
18085   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18086   std::string *arg2 = 0 ;
18087   Dali::Property::Map *arg3 = 0 ;
18088   bool result;
18089
18090   arg1 = (Dali::BaseObject *)jarg1;
18091   if (!jarg2) {
18092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18093     return 0;
18094   }
18095   std::string arg2_str(jarg2);
18096   arg2 = &arg2_str;
18097   arg3 = (Dali::Property::Map *)jarg3;
18098   if (!arg3) {
18099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18100     return 0;
18101   }
18102   {
18103     try {
18104       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18105     } catch (std::out_of_range& e) {
18106       {
18107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (std::exception& e) {
18110       {
18111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18112       };
18113     } catch (Dali::DaliException e) {
18114       {
18115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18116       };
18117     } catch (...) {
18118       {
18119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18120       };
18121     }
18122   }
18123
18124   jresult = result;
18125
18126   //argout typemap for const std::string&
18127
18128   return jresult;
18129 }
18130
18131
18132 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18133   char * jresult ;
18134   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18135   std::string *result = 0 ;
18136
18137   arg1 = (Dali::BaseObject *)jarg1;
18138   {
18139     try {
18140       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18141     } catch (std::out_of_range& e) {
18142       {
18143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18144       };
18145     } catch (std::exception& e) {
18146       {
18147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18148       };
18149     } catch (Dali::DaliException e) {
18150       {
18151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18152       };
18153     } catch (...) {
18154       {
18155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18156       };
18157     }
18158   }
18159
18160   jresult = SWIG_csharp_string_callback(result->c_str());
18161   return jresult;
18162 }
18163
18164
18165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18166   unsigned int jresult ;
18167   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18168   Dali::TypeInfo *arg2 = 0 ;
18169   bool result;
18170
18171   arg1 = (Dali::BaseObject *)jarg1;
18172   arg2 = (Dali::TypeInfo *)jarg2;
18173   if (!arg2) {
18174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18175     return 0;
18176   }
18177   {
18178     try {
18179       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18180     } catch (std::out_of_range& e) {
18181       {
18182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18183       };
18184     } catch (std::exception& e) {
18185       {
18186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18187       };
18188     } catch (Dali::DaliException e) {
18189       {
18190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18191       };
18192     } catch (...) {
18193       {
18194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18195       };
18196     }
18197   }
18198
18199   jresult = result;
18200   return jresult;
18201 }
18202
18203
18204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18205   unsigned int jresult ;
18206   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18207   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18208   std::string *arg3 = 0 ;
18209   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18210   bool result;
18211
18212   arg1 = (Dali::BaseObject *)jarg1;
18213   arg2 = (ConnectionTrackerInterface *)jarg2;
18214   if (!jarg3) {
18215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18216     return 0;
18217   }
18218   std::string arg3_str(jarg3);
18219   arg3 = &arg3_str;
18220   arg4 = (FunctorDelegate *)jarg4;
18221   {
18222     try {
18223       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18224     } catch (std::out_of_range& e) {
18225       {
18226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18227       };
18228     } catch (std::exception& e) {
18229       {
18230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18231       };
18232     } catch (Dali::DaliException e) {
18233       {
18234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18235       };
18236     } catch (...) {
18237       {
18238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18239       };
18240     }
18241   }
18242
18243   jresult = result;
18244
18245   //argout typemap for const std::string&
18246
18247   return jresult;
18248 }
18249
18250
18251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18252   void * jresult ;
18253   Dali::BaseHandle *arg1 = 0 ;
18254   Dali::BaseObject *result = 0 ;
18255
18256   arg1 = (Dali::BaseHandle *)jarg1;
18257   if (!arg1) {
18258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18259     return 0;
18260   }
18261   {
18262     try {
18263       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18264     } catch (std::out_of_range& e) {
18265       {
18266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18267       };
18268     } catch (std::exception& e) {
18269       {
18270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18271       };
18272     } catch (Dali::DaliException e) {
18273       {
18274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18275       };
18276     } catch (...) {
18277       {
18278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18279       };
18280     }
18281   }
18282
18283   jresult = (void *)result;
18284   return jresult;
18285 }
18286
18287
18288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18289   void * jresult ;
18290   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18291   Dali::BaseHandle *result = 0 ;
18292
18293   arg1 = (Dali::BaseObject *)jarg1;
18294   {
18295     try {
18296       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18297     } catch (std::out_of_range& e) {
18298       {
18299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18300       };
18301     } catch (std::exception& e) {
18302       {
18303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18304       };
18305     } catch (Dali::DaliException e) {
18306       {
18307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18308       };
18309     } catch (...) {
18310       {
18311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18312       };
18313     }
18314   }
18315
18316   jresult = (void *)result;
18317   return jresult;
18318 }
18319
18320
18321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18322   void * jresult ;
18323   Dali::BaseHandle *result = 0 ;
18324
18325   {
18326     try {
18327       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18328     } catch (std::out_of_range& e) {
18329       {
18330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (std::exception& e) {
18333       {
18334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (Dali::DaliException e) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346
18347   jresult = (void *)result;
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18353   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18354
18355   arg1 = (Dali::BaseHandle *)jarg1;
18356   {
18357     try {
18358       delete arg1;
18359     } catch (std::out_of_range& e) {
18360       {
18361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18362       };
18363     } catch (std::exception& e) {
18364       {
18365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18366       };
18367     } catch (Dali::DaliException e) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18370       };
18371     } catch (...) {
18372       {
18373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18374       };
18375     }
18376   }
18377
18378 }
18379
18380
18381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18382   void * jresult ;
18383   Dali::BaseHandle *arg1 = 0 ;
18384   Dali::BaseHandle *result = 0 ;
18385
18386   arg1 = (Dali::BaseHandle *)jarg1;
18387   if (!arg1) {
18388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18389     return 0;
18390   }
18391   {
18392     try {
18393       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18394     } catch (std::out_of_range& e) {
18395       {
18396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18397       };
18398     } catch (std::exception& e) {
18399       {
18400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18401       };
18402     } catch (Dali::DaliException e) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18405       };
18406     } catch (...) {
18407       {
18408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18409       };
18410     }
18411   }
18412
18413   jresult = (void *)result;
18414   return jresult;
18415 }
18416
18417
18418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18419   void * jresult ;
18420   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18421   Dali::BaseHandle *arg2 = 0 ;
18422   Dali::BaseHandle *result = 0 ;
18423
18424   arg1 = (Dali::BaseHandle *)jarg1;
18425   arg2 = (Dali::BaseHandle *)jarg2;
18426   if (!arg2) {
18427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18428     return 0;
18429   }
18430   {
18431     try {
18432       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18433     } catch (std::out_of_range& e) {
18434       {
18435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18436       };
18437     } catch (std::exception& e) {
18438       {
18439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18440       };
18441     } catch (Dali::DaliException e) {
18442       {
18443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18444       };
18445     } catch (...) {
18446       {
18447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18448       };
18449     }
18450   }
18451
18452   jresult = (void *)result;
18453   return jresult;
18454 }
18455
18456
18457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18458   unsigned int jresult ;
18459   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18460   std::string *arg2 = 0 ;
18461   Dali::Property::Map *arg3 = 0 ;
18462   bool result;
18463
18464   arg1 = (Dali::BaseHandle *)jarg1;
18465   if (!jarg2) {
18466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18467     return 0;
18468   }
18469   std::string arg2_str(jarg2);
18470   arg2 = &arg2_str;
18471   arg3 = (Dali::Property::Map *)jarg3;
18472   if (!arg3) {
18473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18474     return 0;
18475   }
18476   {
18477     try {
18478       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18479     } catch (std::out_of_range& e) {
18480       {
18481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18482       };
18483     } catch (std::exception& e) {
18484       {
18485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18486       };
18487     } catch (Dali::DaliException e) {
18488       {
18489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18490       };
18491     } catch (...) {
18492       {
18493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18494       };
18495     }
18496   }
18497
18498   jresult = result;
18499
18500   //argout typemap for const std::string&
18501
18502   return jresult;
18503 }
18504
18505
18506 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18507   char * jresult ;
18508   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18509   std::string *result = 0 ;
18510
18511   arg1 = (Dali::BaseHandle *)jarg1;
18512   {
18513     try {
18514       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18515     } catch (std::out_of_range& e) {
18516       {
18517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18518       };
18519     } catch (std::exception& e) {
18520       {
18521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18522       };
18523     } catch (Dali::DaliException e) {
18524       {
18525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18526       };
18527     } catch (...) {
18528       {
18529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18530       };
18531     }
18532   }
18533
18534   jresult = SWIG_csharp_string_callback(result->c_str());
18535   return jresult;
18536 }
18537
18538
18539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18540   unsigned int jresult ;
18541   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18542   Dali::TypeInfo *arg2 = 0 ;
18543   bool result;
18544
18545   arg1 = (Dali::BaseHandle *)jarg1;
18546   arg2 = (Dali::TypeInfo *)jarg2;
18547   if (!arg2) {
18548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18549     return 0;
18550   }
18551   {
18552     try {
18553       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18561       };
18562     } catch (Dali::DaliException e) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18565       };
18566     } catch (...) {
18567       {
18568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18569       };
18570     }
18571   }
18572
18573   jresult = result;
18574   return jresult;
18575 }
18576
18577
18578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18579   void * jresult ;
18580   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18581   Dali::BaseObject *result = 0 ;
18582
18583   arg1 = (Dali::BaseHandle *)jarg1;
18584   {
18585     try {
18586       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18587     } catch (std::out_of_range& e) {
18588       {
18589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18590       };
18591     } catch (std::exception& e) {
18592       {
18593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (Dali::DaliException e) {
18596       {
18597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18598       };
18599     } catch (...) {
18600       {
18601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18602       };
18603     }
18604   }
18605
18606   jresult = (void *)result;
18607   return jresult;
18608 }
18609
18610
18611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18612   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18613
18614   arg1 = (Dali::BaseHandle *)jarg1;
18615   {
18616     try {
18617       (arg1)->Reset();
18618     } catch (std::out_of_range& e) {
18619       {
18620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18621       };
18622     } catch (std::exception& e) {
18623       {
18624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18625       };
18626     } catch (Dali::DaliException e) {
18627       {
18628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18629       };
18630     } catch (...) {
18631       {
18632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18633       };
18634     }
18635   }
18636
18637 }
18638
18639
18640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18641   unsigned int jresult ;
18642   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18643   Dali::BaseHandle *arg2 = 0 ;
18644   bool result;
18645
18646   arg1 = (Dali::BaseHandle *)jarg1;
18647   arg2 = (Dali::BaseHandle *)jarg2;
18648   if (!arg2) {
18649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18650     return 0;
18651   }
18652   {
18653     try {
18654       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18655     } catch (std::out_of_range& e) {
18656       {
18657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (std::exception& e) {
18660       {
18661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18662       };
18663     } catch (Dali::DaliException e) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18666       };
18667     } catch (...) {
18668       {
18669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18670       };
18671     }
18672   }
18673
18674   jresult = result;
18675   return jresult;
18676 }
18677
18678
18679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18680   unsigned int jresult ;
18681   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18682   Dali::BaseHandle *arg2 = 0 ;
18683   bool result;
18684
18685   arg1 = (Dali::BaseHandle *)jarg1;
18686   arg2 = (Dali::BaseHandle *)jarg2;
18687   if (!arg2) {
18688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18689     return 0;
18690   }
18691   {
18692     try {
18693       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18694     } catch (std::out_of_range& e) {
18695       {
18696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18697       };
18698     } catch (std::exception& e) {
18699       {
18700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18701       };
18702     } catch (Dali::DaliException e) {
18703       {
18704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18705       };
18706     } catch (...) {
18707       {
18708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18709       };
18710     }
18711   }
18712
18713   jresult = result;
18714   return jresult;
18715 }
18716
18717
18718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18719   void * jresult ;
18720   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18721   Dali::RefObject *result = 0 ;
18722
18723   arg1 = (Dali::BaseHandle *)jarg1;
18724   {
18725     try {
18726       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (Dali::DaliException e) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18738       };
18739     } catch (...) {
18740       {
18741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18742       };
18743     }
18744   }
18745
18746   jresult = (void *)result;
18747   return jresult;
18748 }
18749
18750
18751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18752   unsigned int jresult ;
18753   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18754   bool result;
18755
18756   arg1 = (Dali::BaseHandle *)jarg1;
18757   {
18758     try {
18759       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18760     } catch (std::out_of_range& e) {
18761       {
18762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (std::exception& e) {
18765       {
18766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18767       };
18768     } catch (Dali::DaliException e) {
18769       {
18770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18771       };
18772     } catch (...) {
18773       {
18774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18775       };
18776     }
18777   }
18778
18779   jresult = result;
18780   return jresult;
18781 }
18782
18783
18784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18785   unsigned int jresult ;
18786   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18787   Dali::BaseHandle *arg2 = 0 ;
18788   bool result;
18789
18790   arg1 = (Dali::BaseHandle *)jarg1;
18791   arg2 = (Dali::BaseHandle *)jarg2;
18792   if (!arg2) {
18793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18794     return 0;
18795   }
18796   {
18797     try {
18798       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18799     } catch (std::out_of_range& e) {
18800       {
18801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18802       };
18803     } catch (std::exception& e) {
18804       {
18805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18806       };
18807     } catch (Dali::DaliException e) {
18808       {
18809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18810       };
18811     } catch (...) {
18812       {
18813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18814       };
18815     }
18816   }
18817
18818   jresult = result;
18819   return jresult;
18820 }
18821
18822
18823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18824   unsigned int jresult ;
18825   Dali::BaseHandle *arg1 = 0 ;
18826   Dali::BaseHandle *arg2 = 0 ;
18827   bool result;
18828
18829   arg1 = (Dali::BaseHandle *)jarg1;
18830   if (!arg1) {
18831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18832     return 0;
18833   }
18834   arg2 = (Dali::BaseHandle *)jarg2;
18835   if (!arg2) {
18836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18837     return 0;
18838   }
18839   {
18840     try {
18841       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18842     } catch (std::out_of_range& e) {
18843       {
18844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18845       };
18846     } catch (std::exception& e) {
18847       {
18848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (Dali::DaliException e) {
18851       {
18852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18853       };
18854     } catch (...) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18857       };
18858     }
18859   }
18860
18861   jresult = result;
18862   return jresult;
18863 }
18864
18865
18866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18867   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18868
18869   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18870   {
18871     try {
18872       delete arg1;
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18880       };
18881     } catch (Dali::DaliException e) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18888       };
18889     }
18890   }
18891
18892 }
18893
18894
18895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18896   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18897   SlotObserver *arg2 = (SlotObserver *) 0 ;
18898   CallbackBase *arg3 = (CallbackBase *) 0 ;
18899
18900   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18901   arg2 = (SlotObserver *)jarg2;
18902   arg3 = (CallbackBase *)jarg3;
18903   {
18904     try {
18905       (arg1)->SignalConnected(arg2,arg3);
18906     } catch (std::out_of_range& e) {
18907       {
18908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18909       };
18910     } catch (std::exception& e) {
18911       {
18912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18913       };
18914     } catch (Dali::DaliException e) {
18915       {
18916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18917       };
18918     } catch (...) {
18919       {
18920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18921       };
18922     }
18923   }
18924
18925 }
18926
18927
18928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18929   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18930
18931   arg1 = (Dali::SignalObserver *)jarg1;
18932   {
18933     try {
18934       delete arg1;
18935     } catch (std::out_of_range& e) {
18936       {
18937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18938       };
18939     } catch (std::exception& e) {
18940       {
18941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18942       };
18943     } catch (Dali::DaliException e) {
18944       {
18945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18946       };
18947     } catch (...) {
18948       {
18949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18950       };
18951     }
18952   }
18953
18954 }
18955
18956
18957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18958   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18959   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18960   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18961
18962   arg1 = (Dali::SignalObserver *)jarg1;
18963   arg2 = (Dali::SlotObserver *)jarg2;
18964   arg3 = (Dali::CallbackBase *)jarg3;
18965   {
18966     try {
18967       (arg1)->SignalDisconnected(arg2,arg3);
18968     } catch (std::out_of_range& e) {
18969       {
18970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18971       };
18972     } catch (std::exception& e) {
18973       {
18974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18975       };
18976     } catch (Dali::DaliException e) {
18977       {
18978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18979       };
18980     } catch (...) {
18981       {
18982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18983       };
18984     }
18985   }
18986
18987 }
18988
18989
18990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18991   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18992
18993   arg1 = (Dali::SlotObserver *)jarg1;
18994   {
18995     try {
18996       delete arg1;
18997     } catch (std::out_of_range& e) {
18998       {
18999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19000       };
19001     } catch (std::exception& e) {
19002       {
19003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19004       };
19005     } catch (Dali::DaliException e) {
19006       {
19007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19008       };
19009     } catch (...) {
19010       {
19011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19012       };
19013     }
19014   }
19015
19016 }
19017
19018
19019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19020   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19021   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19022
19023   arg1 = (Dali::SlotObserver *)jarg1;
19024   arg2 = (Dali::CallbackBase *)jarg2;
19025   {
19026     try {
19027       (arg1)->SlotDisconnected(arg2);
19028     } catch (std::out_of_range& e) {
19029       {
19030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (std::exception& e) {
19033       {
19034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (Dali::DaliException e) {
19037       {
19038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19039       };
19040     } catch (...) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19043       };
19044     }
19045   }
19046
19047 }
19048
19049
19050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19051   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19052
19053   arg1 = (Dali::ConnectionTracker *)jarg1;
19054   {
19055     try {
19056       delete arg1;
19057     } catch (std::out_of_range& e) {
19058       {
19059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19060       };
19061     } catch (std::exception& e) {
19062       {
19063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19064       };
19065     } catch (Dali::DaliException e) {
19066       {
19067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19068       };
19069     } catch (...) {
19070       {
19071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19072       };
19073     }
19074   }
19075
19076 }
19077
19078
19079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19080   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19081
19082   arg1 = (Dali::ConnectionTracker *)jarg1;
19083   {
19084     try {
19085       (arg1)->DisconnectAll();
19086     } catch (std::out_of_range& e) {
19087       {
19088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19089       };
19090     } catch (std::exception& e) {
19091       {
19092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19093       };
19094     } catch (Dali::DaliException e) {
19095       {
19096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19097       };
19098     } catch (...) {
19099       {
19100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19101       };
19102     }
19103   }
19104
19105 }
19106
19107
19108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19109   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19110   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19111   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19112
19113   arg1 = (Dali::ConnectionTracker *)jarg1;
19114   arg2 = (Dali::SlotObserver *)jarg2;
19115   arg3 = (Dali::CallbackBase *)jarg3;
19116   {
19117     try {
19118       (arg1)->SignalConnected(arg2,arg3);
19119     } catch (std::out_of_range& e) {
19120       {
19121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19122       };
19123     } catch (std::exception& e) {
19124       {
19125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19126       };
19127     } catch (Dali::DaliException e) {
19128       {
19129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19130       };
19131     } catch (...) {
19132       {
19133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19134       };
19135     }
19136   }
19137
19138 }
19139
19140
19141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19142   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19143   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19144   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19145
19146   arg1 = (Dali::ConnectionTracker *)jarg1;
19147   arg2 = (Dali::SlotObserver *)jarg2;
19148   arg3 = (Dali::CallbackBase *)jarg3;
19149   {
19150     try {
19151       (arg1)->SignalDisconnected(arg2,arg3);
19152     } catch (std::out_of_range& e) {
19153       {
19154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19155       };
19156     } catch (std::exception& e) {
19157       {
19158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19159       };
19160     } catch (Dali::DaliException e) {
19161       {
19162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19167       };
19168     }
19169   }
19170
19171 }
19172
19173
19174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19175   unsigned long jresult ;
19176   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19177   std::size_t result;
19178
19179   arg1 = (Dali::ConnectionTracker *)jarg1;
19180   {
19181     try {
19182       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19183     } catch (std::out_of_range& e) {
19184       {
19185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19186       };
19187     } catch (std::exception& e) {
19188       {
19189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19190       };
19191     } catch (Dali::DaliException e) {
19192       {
19193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19198       };
19199     }
19200   }
19201
19202   jresult = (unsigned long)result;
19203   return jresult;
19204 }
19205
19206
19207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19208   void * jresult ;
19209   Dali::ObjectRegistry *result = 0 ;
19210
19211   {
19212     try {
19213       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (Dali::DaliException e) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19225       };
19226     } catch (...) {
19227       {
19228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19229       };
19230     }
19231   }
19232
19233   jresult = (void *)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19239   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19240
19241   arg1 = (Dali::ObjectRegistry *)jarg1;
19242   {
19243     try {
19244       delete arg1;
19245     } catch (std::out_of_range& e) {
19246       {
19247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19248       };
19249     } catch (std::exception& e) {
19250       {
19251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19252       };
19253     } catch (Dali::DaliException e) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19260       };
19261     }
19262   }
19263
19264 }
19265
19266
19267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19268   void * jresult ;
19269   Dali::ObjectRegistry *arg1 = 0 ;
19270   Dali::ObjectRegistry *result = 0 ;
19271
19272   arg1 = (Dali::ObjectRegistry *)jarg1;
19273   if (!arg1) {
19274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19275     return 0;
19276   }
19277   {
19278     try {
19279       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19280     } catch (std::out_of_range& e) {
19281       {
19282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19283       };
19284     } catch (std::exception& e) {
19285       {
19286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19287       };
19288     } catch (Dali::DaliException e) {
19289       {
19290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19291       };
19292     } catch (...) {
19293       {
19294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19295       };
19296     }
19297   }
19298
19299   jresult = (void *)result;
19300   return jresult;
19301 }
19302
19303
19304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19305   void * jresult ;
19306   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19307   Dali::ObjectRegistry *arg2 = 0 ;
19308   Dali::ObjectRegistry *result = 0 ;
19309
19310   arg1 = (Dali::ObjectRegistry *)jarg1;
19311   arg2 = (Dali::ObjectRegistry *)jarg2;
19312   if (!arg2) {
19313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19314     return 0;
19315   }
19316   {
19317     try {
19318       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19319     } catch (std::out_of_range& e) {
19320       {
19321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (std::exception& e) {
19324       {
19325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19326       };
19327     } catch (Dali::DaliException e) {
19328       {
19329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19330       };
19331     } catch (...) {
19332       {
19333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19334       };
19335     }
19336   }
19337
19338   jresult = (void *)result;
19339   return jresult;
19340 }
19341
19342
19343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19344   void * jresult ;
19345   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19346   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19347
19348   arg1 = (Dali::ObjectRegistry *)jarg1;
19349   {
19350     try {
19351       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19352     } catch (std::out_of_range& e) {
19353       {
19354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19355       };
19356     } catch (std::exception& e) {
19357       {
19358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (Dali::DaliException e) {
19361       {
19362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19363       };
19364     } catch (...) {
19365       {
19366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19367       };
19368     }
19369   }
19370
19371   jresult = (void *)result;
19372   return jresult;
19373 }
19374
19375
19376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19377   void * jresult ;
19378   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19379   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19380
19381   arg1 = (Dali::ObjectRegistry *)jarg1;
19382   {
19383     try {
19384       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19385     } catch (std::out_of_range& e) {
19386       {
19387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19388       };
19389     } catch (std::exception& e) {
19390       {
19391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19392       };
19393     } catch (Dali::DaliException e) {
19394       {
19395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19396       };
19397     } catch (...) {
19398       {
19399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19400       };
19401     }
19402   }
19403
19404   jresult = (void *)result;
19405   return jresult;
19406 }
19407
19408
19409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19410   void * jresult ;
19411   Dali::PropertyCondition *result = 0 ;
19412
19413   {
19414     try {
19415       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19416     } catch (std::out_of_range& e) {
19417       {
19418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19419       };
19420     } catch (std::exception& e) {
19421       {
19422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19423       };
19424     } catch (Dali::DaliException e) {
19425       {
19426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19427       };
19428     } catch (...) {
19429       {
19430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19431       };
19432     }
19433   }
19434
19435   jresult = (void *)result;
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19441   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19442
19443   arg1 = (Dali::PropertyCondition *)jarg1;
19444   {
19445     try {
19446       delete arg1;
19447     } catch (std::out_of_range& e) {
19448       {
19449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19450       };
19451     } catch (std::exception& e) {
19452       {
19453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19454       };
19455     } catch (Dali::DaliException e) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19458       };
19459     } catch (...) {
19460       {
19461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19462       };
19463     }
19464   }
19465
19466 }
19467
19468
19469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19470   void * jresult ;
19471   Dali::PropertyCondition *arg1 = 0 ;
19472   Dali::PropertyCondition *result = 0 ;
19473
19474   arg1 = (Dali::PropertyCondition *)jarg1;
19475   if (!arg1) {
19476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19477     return 0;
19478   }
19479   {
19480     try {
19481       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19482     } catch (std::out_of_range& e) {
19483       {
19484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19485       };
19486     } catch (std::exception& e) {
19487       {
19488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19489       };
19490     } catch (Dali::DaliException e) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19493       };
19494     } catch (...) {
19495       {
19496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19497       };
19498     }
19499   }
19500
19501   jresult = (void *)result;
19502   return jresult;
19503 }
19504
19505
19506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19507   void * jresult ;
19508   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19509   Dali::PropertyCondition *arg2 = 0 ;
19510   Dali::PropertyCondition *result = 0 ;
19511
19512   arg1 = (Dali::PropertyCondition *)jarg1;
19513   arg2 = (Dali::PropertyCondition *)jarg2;
19514   if (!arg2) {
19515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19516     return 0;
19517   }
19518   {
19519     try {
19520       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19521     } catch (std::out_of_range& e) {
19522       {
19523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (std::exception& e) {
19526       {
19527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19528       };
19529     } catch (Dali::DaliException e) {
19530       {
19531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19532       };
19533     } catch (...) {
19534       {
19535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19536       };
19537     }
19538   }
19539
19540   jresult = (void *)result;
19541   return jresult;
19542 }
19543
19544
19545 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19546   unsigned long jresult ;
19547   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19548   std::size_t result;
19549
19550   arg1 = (Dali::PropertyCondition *)jarg1;
19551   {
19552     try {
19553       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19554     } catch (std::out_of_range& e) {
19555       {
19556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19557       };
19558     } catch (std::exception& e) {
19559       {
19560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19561       };
19562     } catch (...) {
19563       {
19564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19565       };
19566     }
19567   }
19568   jresult = (unsigned long)result;
19569   return jresult;
19570 }
19571
19572
19573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19574   float jresult ;
19575   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19576   std::size_t arg2 ;
19577   float result;
19578
19579   arg1 = (Dali::PropertyCondition *)jarg1;
19580   arg2 = (std::size_t)jarg2;
19581   {
19582     try {
19583       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19584     } catch (std::out_of_range& e) {
19585       {
19586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (std::exception& e) {
19589       {
19590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (...) {
19593       {
19594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19595       };
19596     }
19597   }
19598   jresult = result;
19599   return jresult;
19600 }
19601
19602
19603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19604   void * jresult ;
19605   float arg1 ;
19606   Dali::PropertyCondition result;
19607
19608   arg1 = (float)jarg1;
19609   {
19610     try {
19611       result = Dali::LessThanCondition(arg1);
19612     } catch (std::out_of_range& e) {
19613       {
19614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19615       };
19616     } catch (std::exception& e) {
19617       {
19618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19619       };
19620     } catch (Dali::DaliException e) {
19621       {
19622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19623       };
19624     } catch (...) {
19625       {
19626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19627       };
19628     }
19629   }
19630
19631   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19632   return jresult;
19633 }
19634
19635
19636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19637   void * jresult ;
19638   float arg1 ;
19639   Dali::PropertyCondition result;
19640
19641   arg1 = (float)jarg1;
19642   {
19643     try {
19644       result = Dali::GreaterThanCondition(arg1);
19645     } catch (std::out_of_range& e) {
19646       {
19647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19648       };
19649     } catch (std::exception& e) {
19650       {
19651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19652       };
19653     } catch (Dali::DaliException e) {
19654       {
19655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19656       };
19657     } catch (...) {
19658       {
19659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19660       };
19661     }
19662   }
19663
19664   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19665   return jresult;
19666 }
19667
19668
19669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19670   void * jresult ;
19671   float arg1 ;
19672   float arg2 ;
19673   Dali::PropertyCondition result;
19674
19675   arg1 = (float)jarg1;
19676   arg2 = (float)jarg2;
19677   {
19678     try {
19679       result = Dali::InsideCondition(arg1,arg2);
19680     } catch (std::out_of_range& e) {
19681       {
19682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (std::exception& e) {
19685       {
19686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19687       };
19688     } catch (Dali::DaliException e) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19691       };
19692     } catch (...) {
19693       {
19694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19695       };
19696     }
19697   }
19698
19699   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19700   return jresult;
19701 }
19702
19703
19704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19705   void * jresult ;
19706   float arg1 ;
19707   float arg2 ;
19708   Dali::PropertyCondition result;
19709
19710   arg1 = (float)jarg1;
19711   arg2 = (float)jarg2;
19712   {
19713     try {
19714       result = Dali::OutsideCondition(arg1,arg2);
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19722       };
19723     } catch (Dali::DaliException e) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19726       };
19727     } catch (...) {
19728       {
19729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19730       };
19731     }
19732   }
19733
19734   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19735   return jresult;
19736 }
19737
19738
19739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19740   void * jresult ;
19741   float arg1 ;
19742   float arg2 ;
19743   Dali::PropertyCondition result;
19744
19745   arg1 = (float)jarg1;
19746   arg2 = (float)jarg2;
19747   {
19748     try {
19749       result = Dali::StepCondition(arg1,arg2);
19750     } catch (std::out_of_range& e) {
19751       {
19752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (std::exception& e) {
19755       {
19756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19757       };
19758     } catch (Dali::DaliException e) {
19759       {
19760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19761       };
19762     } catch (...) {
19763       {
19764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19765       };
19766     }
19767   }
19768
19769   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19770   return jresult;
19771 }
19772
19773
19774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19775   void * jresult ;
19776   float arg1 ;
19777   Dali::PropertyCondition result;
19778
19779   arg1 = (float)jarg1;
19780   {
19781     try {
19782       result = Dali::StepCondition(arg1);
19783     } catch (std::out_of_range& e) {
19784       {
19785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19786       };
19787     } catch (std::exception& e) {
19788       {
19789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19790       };
19791     } catch (Dali::DaliException e) {
19792       {
19793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19794       };
19795     } catch (...) {
19796       {
19797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19798       };
19799     }
19800   }
19801
19802   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19803   return jresult;
19804 }
19805
19806
19807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19808   void * jresult ;
19809   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19810   Dali::PropertyCondition result;
19811
19812   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19813   if (!arg1) {
19814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19815     return 0;
19816   }
19817   {
19818     try {
19819       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19820     } catch (std::out_of_range& e) {
19821       {
19822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19823       };
19824     } catch (std::exception& e) {
19825       {
19826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19827       };
19828     } catch (Dali::DaliException e) {
19829       {
19830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19831       };
19832     } catch (...) {
19833       {
19834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19835       };
19836     }
19837   }
19838
19839   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19840   return jresult;
19841 }
19842
19843
19844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19845   void * jresult ;
19846   Dali::PropertyNotification *result = 0 ;
19847
19848   {
19849     try {
19850       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (Dali::DaliException e) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19862       };
19863     } catch (...) {
19864       {
19865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19866       };
19867     }
19868   }
19869
19870   jresult = (void *)result;
19871   return jresult;
19872 }
19873
19874
19875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19876   void * jresult ;
19877   Dali::BaseHandle arg1 ;
19878   Dali::BaseHandle *argp1 ;
19879   Dali::PropertyNotification result;
19880
19881   argp1 = (Dali::BaseHandle *)jarg1;
19882   if (!argp1) {
19883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19884     return 0;
19885   }
19886   arg1 = *argp1;
19887   {
19888     try {
19889       result = Dali::PropertyNotification::DownCast(arg1);
19890     } catch (std::out_of_range& e) {
19891       {
19892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19893       };
19894     } catch (std::exception& e) {
19895       {
19896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19897       };
19898     } catch (Dali::DaliException e) {
19899       {
19900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19901       };
19902     } catch (...) {
19903       {
19904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19905       };
19906     }
19907   }
19908
19909   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19910   return jresult;
19911 }
19912
19913
19914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19915   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19916
19917   arg1 = (Dali::PropertyNotification *)jarg1;
19918   {
19919     try {
19920       delete arg1;
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19928       };
19929     } catch (Dali::DaliException e) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19932       };
19933     } catch (...) {
19934       {
19935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19936       };
19937     }
19938   }
19939
19940 }
19941
19942
19943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19944   void * jresult ;
19945   Dali::PropertyNotification *arg1 = 0 ;
19946   Dali::PropertyNotification *result = 0 ;
19947
19948   arg1 = (Dali::PropertyNotification *)jarg1;
19949   if (!arg1) {
19950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19951     return 0;
19952   }
19953   {
19954     try {
19955       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19956     } catch (std::out_of_range& e) {
19957       {
19958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (std::exception& e) {
19961       {
19962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19963       };
19964     } catch (Dali::DaliException e) {
19965       {
19966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19967       };
19968     } catch (...) {
19969       {
19970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19971       };
19972     }
19973   }
19974
19975   jresult = (void *)result;
19976   return jresult;
19977 }
19978
19979
19980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19981   void * jresult ;
19982   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19983   Dali::PropertyNotification *arg2 = 0 ;
19984   Dali::PropertyNotification *result = 0 ;
19985
19986   arg1 = (Dali::PropertyNotification *)jarg1;
19987   arg2 = (Dali::PropertyNotification *)jarg2;
19988   if (!arg2) {
19989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19990     return 0;
19991   }
19992   {
19993     try {
19994       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19995     } catch (std::out_of_range& e) {
19996       {
19997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19998       };
19999     } catch (std::exception& e) {
20000       {
20001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20002       };
20003     } catch (Dali::DaliException e) {
20004       {
20005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20006       };
20007     } catch (...) {
20008       {
20009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20010       };
20011     }
20012   }
20013
20014   jresult = (void *)result;
20015   return jresult;
20016 }
20017
20018
20019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20020   void * jresult ;
20021   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20022   Dali::PropertyCondition result;
20023
20024   arg1 = (Dali::PropertyNotification *)jarg1;
20025   {
20026     try {
20027       result = (arg1)->GetCondition();
20028     } catch (std::out_of_range& e) {
20029       {
20030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20031       };
20032     } catch (std::exception& e) {
20033       {
20034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20035       };
20036     } catch (Dali::DaliException e) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20039       };
20040     } catch (...) {
20041       {
20042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20043       };
20044     }
20045   }
20046
20047   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20048   return jresult;
20049 }
20050
20051
20052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20053   void * jresult ;
20054   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20055   Dali::Handle result;
20056
20057   arg1 = (Dali::PropertyNotification *)jarg1;
20058   {
20059     try {
20060       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20061     } catch (std::out_of_range& e) {
20062       {
20063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20064       };
20065     } catch (std::exception& e) {
20066       {
20067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20068       };
20069     } catch (Dali::DaliException e) {
20070       {
20071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20072       };
20073     } catch (...) {
20074       {
20075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20076       };
20077     }
20078   }
20079
20080   jresult = new Dali::Handle((const Dali::Handle &)result);
20081   return jresult;
20082 }
20083
20084
20085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20086   int jresult ;
20087   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20088   Dali::Property::Index result;
20089
20090   arg1 = (Dali::PropertyNotification *)jarg1;
20091   {
20092     try {
20093       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20094     } catch (std::out_of_range& e) {
20095       {
20096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (std::exception& e) {
20099       {
20100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20101       };
20102     } catch (Dali::DaliException e) {
20103       {
20104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20105       };
20106     } catch (...) {
20107       {
20108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20109       };
20110     }
20111   }
20112
20113   jresult = result;
20114   return jresult;
20115 }
20116
20117
20118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20119   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20120   Dali::PropertyNotification::NotifyMode arg2 ;
20121
20122   arg1 = (Dali::PropertyNotification *)jarg1;
20123   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20124   {
20125     try {
20126       (arg1)->SetNotifyMode(arg2);
20127     } catch (std::out_of_range& e) {
20128       {
20129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20130       };
20131     } catch (std::exception& e) {
20132       {
20133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20134       };
20135     } catch (Dali::DaliException e) {
20136       {
20137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20138       };
20139     } catch (...) {
20140       {
20141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20142       };
20143     }
20144   }
20145
20146 }
20147
20148
20149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20150   int jresult ;
20151   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20152   Dali::PropertyNotification::NotifyMode result;
20153
20154   arg1 = (Dali::PropertyNotification *)jarg1;
20155   {
20156     try {
20157       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20158     } catch (std::out_of_range& e) {
20159       {
20160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20161       };
20162     } catch (std::exception& e) {
20163       {
20164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20165       };
20166     } catch (Dali::DaliException e) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20169       };
20170     } catch (...) {
20171       {
20172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20173       };
20174     }
20175   }
20176
20177   jresult = (int)result;
20178   return jresult;
20179 }
20180
20181
20182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20183   unsigned int jresult ;
20184   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20185   bool result;
20186
20187   arg1 = (Dali::PropertyNotification *)jarg1;
20188   {
20189     try {
20190       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20191     } catch (std::out_of_range& e) {
20192       {
20193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20194       };
20195     } catch (std::exception& e) {
20196       {
20197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20198       };
20199     } catch (Dali::DaliException e) {
20200       {
20201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20202       };
20203     } catch (...) {
20204       {
20205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20206       };
20207     }
20208   }
20209
20210   jresult = result;
20211   return jresult;
20212 }
20213
20214
20215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20216   void * jresult ;
20217   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20218   Dali::PropertyNotifySignalType *result = 0 ;
20219
20220   arg1 = (Dali::PropertyNotification *)jarg1;
20221   {
20222     try {
20223       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20224     } catch (std::out_of_range& e) {
20225       {
20226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20227       };
20228     } catch (std::exception& e) {
20229       {
20230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20231       };
20232     } catch (Dali::DaliException e) {
20233       {
20234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20235       };
20236     } catch (...) {
20237       {
20238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20239       };
20240     }
20241   }
20242
20243   jresult = (void *)result;
20244   return jresult;
20245 }
20246
20247
20248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20249   void * jresult ;
20250   Dali::Handle *result = 0 ;
20251
20252   {
20253     try {
20254       result = (Dali::Handle *)new Dali::Handle();
20255     } catch (std::out_of_range& e) {
20256       {
20257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20258       };
20259     } catch (std::exception& e) {
20260       {
20261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20262       };
20263     } catch (Dali::DaliException e) {
20264       {
20265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20266       };
20267     } catch (...) {
20268       {
20269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20270       };
20271     }
20272   }
20273
20274   jresult = (void *)result;
20275   return jresult;
20276 }
20277
20278
20279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20280   void * jresult ;
20281   Dali::Handle result;
20282
20283   {
20284     try {
20285       result = Dali::Handle::New();
20286     } catch (std::out_of_range& e) {
20287       {
20288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20289       };
20290     } catch (std::exception& e) {
20291       {
20292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20293       };
20294     } catch (Dali::DaliException e) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20297       };
20298     } catch (...) {
20299       {
20300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20301       };
20302     }
20303   }
20304
20305   jresult = new Dali::Handle((const Dali::Handle &)result);
20306   return jresult;
20307 }
20308
20309
20310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20311   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20312
20313   arg1 = (Dali::Handle *)jarg1;
20314   {
20315     try {
20316       delete arg1;
20317     } catch (std::out_of_range& e) {
20318       {
20319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20320       };
20321     } catch (std::exception& e) {
20322       {
20323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20324       };
20325     } catch (Dali::DaliException e) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20328       };
20329     } catch (...) {
20330       {
20331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20332       };
20333     }
20334   }
20335
20336 }
20337
20338
20339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20340   void * jresult ;
20341   Dali::Handle *arg1 = 0 ;
20342   Dali::Handle *result = 0 ;
20343
20344   arg1 = (Dali::Handle *)jarg1;
20345   if (!arg1) {
20346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20347     return 0;
20348   }
20349   {
20350     try {
20351       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20352     } catch (std::out_of_range& e) {
20353       {
20354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20355       };
20356     } catch (std::exception& e) {
20357       {
20358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20359       };
20360     } catch (Dali::DaliException e) {
20361       {
20362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20363       };
20364     } catch (...) {
20365       {
20366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20367       };
20368     }
20369   }
20370
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20377   void * jresult ;
20378   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20379   Dali::Handle *arg2 = 0 ;
20380   Dali::Handle *result = 0 ;
20381
20382   arg1 = (Dali::Handle *)jarg1;
20383   arg2 = (Dali::Handle *)jarg2;
20384   if (!arg2) {
20385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20386     return 0;
20387   }
20388   {
20389     try {
20390       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20391     } catch (std::out_of_range& e) {
20392       {
20393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20394       };
20395     } catch (std::exception& e) {
20396       {
20397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20398       };
20399     } catch (Dali::DaliException e) {
20400       {
20401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20402       };
20403     } catch (...) {
20404       {
20405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20406       };
20407     }
20408   }
20409
20410   jresult = (void *)result;
20411   return jresult;
20412 }
20413
20414
20415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20416   void * jresult ;
20417   Dali::BaseHandle arg1 ;
20418   Dali::BaseHandle *argp1 ;
20419   Dali::Handle result;
20420
20421   argp1 = (Dali::BaseHandle *)jarg1;
20422   if (!argp1) {
20423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20424     return 0;
20425   }
20426   arg1 = *argp1;
20427   {
20428     try {
20429       result = Dali::Handle::DownCast(arg1);
20430     } catch (std::out_of_range& e) {
20431       {
20432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20433       };
20434     } catch (std::exception& e) {
20435       {
20436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20437       };
20438     } catch (Dali::DaliException e) {
20439       {
20440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20441       };
20442     } catch (...) {
20443       {
20444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20445       };
20446     }
20447   }
20448
20449   jresult = new Dali::Handle((const Dali::Handle &)result);
20450   return jresult;
20451 }
20452
20453
20454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20455   unsigned int jresult ;
20456   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20457   Dali::Handle::Capability arg2 ;
20458   bool result;
20459
20460   arg1 = (Dali::Handle *)jarg1;
20461   arg2 = (Dali::Handle::Capability)jarg2;
20462   {
20463     try {
20464       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20465     } catch (std::out_of_range& e) {
20466       {
20467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20468       };
20469     } catch (std::exception& e) {
20470       {
20471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20472       };
20473     } catch (Dali::DaliException e) {
20474       {
20475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20476       };
20477     } catch (...) {
20478       {
20479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20480       };
20481     }
20482   }
20483
20484   jresult = result;
20485   return jresult;
20486 }
20487
20488
20489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20490   unsigned int jresult ;
20491   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20492   unsigned int result;
20493
20494   arg1 = (Dali::Handle *)jarg1;
20495   {
20496     try {
20497       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20498     } catch (std::out_of_range& e) {
20499       {
20500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20501       };
20502     } catch (std::exception& e) {
20503       {
20504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20505       };
20506     } catch (Dali::DaliException e) {
20507       {
20508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20509       };
20510     } catch (...) {
20511       {
20512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20513       };
20514     }
20515   }
20516
20517   jresult = result;
20518   return jresult;
20519 }
20520
20521
20522 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20523   char * jresult ;
20524   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20525   Dali::Property::Index arg2 ;
20526   std::string result;
20527
20528   arg1 = (Dali::Handle *)jarg1;
20529   arg2 = (Dali::Property::Index)jarg2;
20530   {
20531     try {
20532       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20533     } catch (std::out_of_range& e) {
20534       {
20535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (std::exception& e) {
20538       {
20539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20540       };
20541     } catch (Dali::DaliException e) {
20542       {
20543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20544       };
20545     } catch (...) {
20546       {
20547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20548       };
20549     }
20550   }
20551
20552   jresult = SWIG_csharp_string_callback((&result)->c_str());
20553   return jresult;
20554 }
20555
20556
20557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20558   int jresult ;
20559   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20560   std::string *arg2 = 0 ;
20561   Dali::Property::Index result;
20562
20563   arg1 = (Dali::Handle *)jarg1;
20564   if (!jarg2) {
20565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20566     return 0;
20567   }
20568   std::string arg2_str(jarg2);
20569   arg2 = &arg2_str;
20570   {
20571     try {
20572       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20573     } catch (std::out_of_range& e) {
20574       {
20575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20576       };
20577     } catch (std::exception& e) {
20578       {
20579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20580       };
20581     } catch (Dali::DaliException e) {
20582       {
20583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20584       };
20585     } catch (...) {
20586       {
20587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20588       };
20589     }
20590   }
20591
20592   jresult = result;
20593
20594   //argout typemap for const std::string&
20595
20596   return jresult;
20597 }
20598
20599
20600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20601   unsigned int jresult ;
20602   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20603   Dali::Property::Index arg2 ;
20604   bool result;
20605
20606   arg1 = (Dali::Handle *)jarg1;
20607   arg2 = (Dali::Property::Index)jarg2;
20608   {
20609     try {
20610       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20611     } catch (std::out_of_range& e) {
20612       {
20613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (std::exception& e) {
20616       {
20617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20618       };
20619     } catch (Dali::DaliException e) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20622       };
20623     } catch (...) {
20624       {
20625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20626       };
20627     }
20628   }
20629
20630   jresult = result;
20631   return jresult;
20632 }
20633
20634
20635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20636   unsigned int jresult ;
20637   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20638   Dali::Property::Index arg2 ;
20639   bool result;
20640
20641   arg1 = (Dali::Handle *)jarg1;
20642   arg2 = (Dali::Property::Index)jarg2;
20643   {
20644     try {
20645       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20646     } catch (std::out_of_range& e) {
20647       {
20648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (std::exception& e) {
20651       {
20652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20653       };
20654     } catch (Dali::DaliException e) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20657       };
20658     } catch (...) {
20659       {
20660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20661       };
20662     }
20663   }
20664
20665   jresult = result;
20666   return jresult;
20667 }
20668
20669
20670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20671   unsigned int jresult ;
20672   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20673   Dali::Property::Index arg2 ;
20674   bool result;
20675
20676   arg1 = (Dali::Handle *)jarg1;
20677   arg2 = (Dali::Property::Index)jarg2;
20678   {
20679     try {
20680       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20681     } catch (std::out_of_range& e) {
20682       {
20683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (std::exception& e) {
20686       {
20687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20688       };
20689     } catch (Dali::DaliException e) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20692       };
20693     } catch (...) {
20694       {
20695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20696       };
20697     }
20698   }
20699
20700   jresult = result;
20701   return jresult;
20702 }
20703
20704
20705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20706   int jresult ;
20707   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20708   Dali::Property::Index arg2 ;
20709   Dali::Property::Type result;
20710
20711   arg1 = (Dali::Handle *)jarg1;
20712   arg2 = (Dali::Property::Index)jarg2;
20713   {
20714     try {
20715       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20716     } catch (std::out_of_range& e) {
20717       {
20718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (std::exception& e) {
20721       {
20722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (Dali::DaliException e) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20727       };
20728     } catch (...) {
20729       {
20730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20731       };
20732     }
20733   }
20734
20735   jresult = (int)result;
20736   return jresult;
20737 }
20738
20739
20740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20741   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20742   Dali::Property::Index arg2 ;
20743   Dali::Property::Value *arg3 = 0 ;
20744
20745   arg1 = (Dali::Handle *)jarg1;
20746   arg2 = (Dali::Property::Index)jarg2;
20747   arg3 = (Dali::Property::Value *)jarg3;
20748   if (!arg3) {
20749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20750     return ;
20751   }
20752   {
20753     try {
20754       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20762       };
20763     } catch (Dali::DaliException e) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20766       };
20767     } catch (...) {
20768       {
20769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20770       };
20771     }
20772   }
20773
20774 }
20775
20776
20777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20778   int jresult ;
20779   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20780   std::string *arg2 = 0 ;
20781   Dali::Property::Value *arg3 = 0 ;
20782   Dali::Property::Index result;
20783
20784   arg1 = (Dali::Handle *)jarg1;
20785   if (!jarg2) {
20786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20787     return 0;
20788   }
20789   std::string arg2_str(jarg2);
20790   arg2 = &arg2_str;
20791   arg3 = (Dali::Property::Value *)jarg3;
20792   if (!arg3) {
20793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20794     return 0;
20795   }
20796   {
20797     try {
20798       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (Dali::DaliException e) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20810       };
20811     } catch (...) {
20812       {
20813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20814       };
20815     }
20816   }
20817
20818   jresult = result;
20819
20820   //argout typemap for const std::string&
20821
20822   return jresult;
20823 }
20824
20825
20826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20827   int jresult ;
20828   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20829   std::string *arg2 = 0 ;
20830   Dali::Property::Value *arg3 = 0 ;
20831   Dali::Property::AccessMode arg4 ;
20832   Dali::Property::Index result;
20833
20834   arg1 = (Dali::Handle *)jarg1;
20835   if (!jarg2) {
20836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20837     return 0;
20838   }
20839   std::string arg2_str(jarg2);
20840   arg2 = &arg2_str;
20841   arg3 = (Dali::Property::Value *)jarg3;
20842   if (!arg3) {
20843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20844     return 0;
20845   }
20846   arg4 = (Dali::Property::AccessMode)jarg4;
20847   {
20848     try {
20849       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20850     } catch (std::out_of_range& e) {
20851       {
20852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (std::exception& e) {
20855       {
20856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20857       };
20858     } catch (Dali::DaliException e) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20861       };
20862     } catch (...) {
20863       {
20864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20865       };
20866     }
20867   }
20868
20869   jresult = result;
20870
20871   //argout typemap for const std::string&
20872
20873   return jresult;
20874 }
20875
20876
20877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20878   void * jresult ;
20879   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20880   Dali::Property::Index arg2 ;
20881   Dali::Property::Value result;
20882
20883   arg1 = (Dali::Handle *)jarg1;
20884   arg2 = (Dali::Property::Index)jarg2;
20885   {
20886     try {
20887       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20888     } catch (std::out_of_range& e) {
20889       {
20890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20891       };
20892     } catch (std::exception& e) {
20893       {
20894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20895       };
20896     } catch (Dali::DaliException e) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20899       };
20900     } catch (...) {
20901       {
20902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20903       };
20904     }
20905   }
20906
20907   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20908   return jresult;
20909 }
20910
20911
20912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20913   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20914   Dali::Property::IndexContainer *arg2 = 0 ;
20915
20916   arg1 = (Dali::Handle *)jarg1;
20917   arg2 = (Dali::Property::IndexContainer *)jarg2;
20918   if (!arg2) {
20919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20920     return ;
20921   }
20922   {
20923     try {
20924       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20925     } catch (std::out_of_range& e) {
20926       {
20927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20928       };
20929     } catch (std::exception& e) {
20930       {
20931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20932       };
20933     } catch (Dali::DaliException e) {
20934       {
20935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20936       };
20937     } catch (...) {
20938       {
20939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20940       };
20941     }
20942   }
20943
20944 }
20945
20946
20947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20948   void * jresult ;
20949   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20950   Dali::Property::Index arg2 ;
20951   Dali::PropertyCondition *arg3 = 0 ;
20952   Dali::PropertyNotification result;
20953
20954   arg1 = (Dali::Handle *)jarg1;
20955   arg2 = (Dali::Property::Index)jarg2;
20956   arg3 = (Dali::PropertyCondition *)jarg3;
20957   if (!arg3) {
20958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20959     return 0;
20960   }
20961   {
20962     try {
20963       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20964     } catch (std::out_of_range& e) {
20965       {
20966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20967       };
20968     } catch (std::exception& e) {
20969       {
20970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20971       };
20972     } catch (Dali::DaliException e) {
20973       {
20974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20975       };
20976     } catch (...) {
20977       {
20978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20979       };
20980     }
20981   }
20982
20983   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20984   return jresult;
20985 }
20986
20987
20988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20989   void * jresult ;
20990   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20991   Dali::Property::Index arg2 ;
20992   int arg3 ;
20993   Dali::PropertyCondition *arg4 = 0 ;
20994   Dali::PropertyNotification result;
20995
20996   arg1 = (Dali::Handle *)jarg1;
20997   arg2 = (Dali::Property::Index)jarg2;
20998   arg3 = (int)jarg3;
20999   arg4 = (Dali::PropertyCondition *)jarg4;
21000   if (!arg4) {
21001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21002     return 0;
21003   }
21004   {
21005     try {
21006       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21007     } catch (std::out_of_range& e) {
21008       {
21009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (std::exception& e) {
21012       {
21013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (Dali::DaliException e) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21018       };
21019     } catch (...) {
21020       {
21021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21022       };
21023     }
21024   }
21025
21026   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21027   return jresult;
21028 }
21029
21030
21031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21032   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21033   Dali::PropertyNotification arg2 ;
21034   Dali::PropertyNotification *argp2 ;
21035
21036   arg1 = (Dali::Handle *)jarg1;
21037   argp2 = (Dali::PropertyNotification *)jarg2;
21038   if (!argp2) {
21039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21040     return ;
21041   }
21042   arg2 = *argp2;
21043   {
21044     try {
21045       (arg1)->RemovePropertyNotification(arg2);
21046     } catch (std::out_of_range& e) {
21047       {
21048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21049       };
21050     } catch (std::exception& e) {
21051       {
21052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21053       };
21054     } catch (Dali::DaliException e) {
21055       {
21056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21057       };
21058     } catch (...) {
21059       {
21060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21061       };
21062     }
21063   }
21064
21065 }
21066
21067
21068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21069   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21070
21071   arg1 = (Dali::Handle *)jarg1;
21072   {
21073     try {
21074       (arg1)->RemovePropertyNotifications();
21075     } catch (std::out_of_range& e) {
21076       {
21077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21078       };
21079     } catch (std::exception& e) {
21080       {
21081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21082       };
21083     } catch (Dali::DaliException e) {
21084       {
21085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21086       };
21087     } catch (...) {
21088       {
21089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21090       };
21091     }
21092   }
21093
21094 }
21095
21096
21097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21098   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21099
21100   arg1 = (Dali::Handle *)jarg1;
21101   {
21102     try {
21103       (arg1)->RemoveConstraints();
21104     } catch (std::out_of_range& e) {
21105       {
21106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21107       };
21108     } catch (std::exception& e) {
21109       {
21110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21111       };
21112     } catch (Dali::DaliException e) {
21113       {
21114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21115       };
21116     } catch (...) {
21117       {
21118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21119       };
21120     }
21121   }
21122
21123 }
21124
21125
21126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21127   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21128   unsigned int arg2 ;
21129
21130   arg1 = (Dali::Handle *)jarg1;
21131   arg2 = (unsigned int)jarg2;
21132   {
21133     try {
21134       (arg1)->RemoveConstraints(arg2);
21135     } catch (std::out_of_range& e) {
21136       {
21137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (std::exception& e) {
21140       {
21141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21142       };
21143     } catch (Dali::DaliException e) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21146       };
21147     } catch (...) {
21148       {
21149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21150       };
21151     }
21152   }
21153
21154 }
21155
21156
21157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21158   int jresult ;
21159   Dali::Property::Index result;
21160
21161   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21162   jresult = result;
21163   return jresult;
21164 }
21165
21166
21167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21168   void * jresult ;
21169   Dali::Handle result;
21170
21171   {
21172     try {
21173       result = Dali::WeightObject::New();
21174     } catch (std::out_of_range& e) {
21175       {
21176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21177       };
21178     } catch (std::exception& e) {
21179       {
21180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21181       };
21182     } catch (Dali::DaliException e) {
21183       {
21184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21185       };
21186     } catch (...) {
21187       {
21188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21189       };
21190     }
21191   }
21192
21193   jresult = new Dali::Handle((const Dali::Handle &)result);
21194   return jresult;
21195 }
21196
21197
21198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21199   void * jresult ;
21200   Dali::TypeInfo *result = 0 ;
21201
21202   {
21203     try {
21204       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21205     } catch (std::out_of_range& e) {
21206       {
21207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (std::exception& e) {
21210       {
21211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21212       };
21213     } catch (Dali::DaliException e) {
21214       {
21215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21216       };
21217     } catch (...) {
21218       {
21219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21220       };
21221     }
21222   }
21223
21224   jresult = (void *)result;
21225   return jresult;
21226 }
21227
21228
21229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21230   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21231
21232   arg1 = (Dali::TypeInfo *)jarg1;
21233   {
21234     try {
21235       delete arg1;
21236     } catch (std::out_of_range& e) {
21237       {
21238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21239       };
21240     } catch (std::exception& e) {
21241       {
21242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21243       };
21244     } catch (Dali::DaliException e) {
21245       {
21246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21247       };
21248     } catch (...) {
21249       {
21250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21251       };
21252     }
21253   }
21254
21255 }
21256
21257
21258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21259   void * jresult ;
21260   Dali::TypeInfo *arg1 = 0 ;
21261   Dali::TypeInfo *result = 0 ;
21262
21263   arg1 = (Dali::TypeInfo *)jarg1;
21264   if (!arg1) {
21265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21266     return 0;
21267   }
21268   {
21269     try {
21270       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21271     } catch (std::out_of_range& e) {
21272       {
21273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21274       };
21275     } catch (std::exception& e) {
21276       {
21277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (Dali::DaliException e) {
21280       {
21281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289
21290   jresult = (void *)result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21296   void * jresult ;
21297   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21298   Dali::TypeInfo *arg2 = 0 ;
21299   Dali::TypeInfo *result = 0 ;
21300
21301   arg1 = (Dali::TypeInfo *)jarg1;
21302   arg2 = (Dali::TypeInfo *)jarg2;
21303   if (!arg2) {
21304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21305     return 0;
21306   }
21307   {
21308     try {
21309       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21310     } catch (std::out_of_range& e) {
21311       {
21312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21313       };
21314     } catch (std::exception& e) {
21315       {
21316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21317       };
21318     } catch (Dali::DaliException e) {
21319       {
21320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21321       };
21322     } catch (...) {
21323       {
21324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21325       };
21326     }
21327   }
21328
21329   jresult = (void *)result;
21330   return jresult;
21331 }
21332
21333
21334 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21335   char * jresult ;
21336   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21337   std::string *result = 0 ;
21338
21339   arg1 = (Dali::TypeInfo *)jarg1;
21340   {
21341     try {
21342       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21343     } catch (std::out_of_range& e) {
21344       {
21345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21346       };
21347     } catch (std::exception& e) {
21348       {
21349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21350       };
21351     } catch (Dali::DaliException e) {
21352       {
21353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21354       };
21355     } catch (...) {
21356       {
21357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21358       };
21359     }
21360   }
21361
21362   jresult = SWIG_csharp_string_callback(result->c_str());
21363   return jresult;
21364 }
21365
21366
21367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21368   char * jresult ;
21369   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21370   std::string *result = 0 ;
21371
21372   arg1 = (Dali::TypeInfo *)jarg1;
21373   {
21374     try {
21375       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21376     } catch (std::out_of_range& e) {
21377       {
21378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21379       };
21380     } catch (std::exception& e) {
21381       {
21382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21383       };
21384     } catch (Dali::DaliException e) {
21385       {
21386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21387       };
21388     } catch (...) {
21389       {
21390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21391       };
21392     }
21393   }
21394
21395   jresult = SWIG_csharp_string_callback(result->c_str());
21396   return jresult;
21397 }
21398
21399
21400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21401   void * jresult ;
21402   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21403   Dali::BaseHandle result;
21404
21405   arg1 = (Dali::TypeInfo *)jarg1;
21406   {
21407     try {
21408       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21409     } catch (std::out_of_range& e) {
21410       {
21411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21412       };
21413     } catch (std::exception& e) {
21414       {
21415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21416       };
21417     } catch (Dali::DaliException e) {
21418       {
21419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21420       };
21421     } catch (...) {
21422       {
21423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21424       };
21425     }
21426   }
21427
21428   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21429   return jresult;
21430 }
21431
21432
21433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21434   unsigned long jresult ;
21435   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21436   size_t result;
21437
21438   arg1 = (Dali::TypeInfo *)jarg1;
21439   {
21440     try {
21441       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21442     } catch (std::out_of_range& e) {
21443       {
21444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21445       };
21446     } catch (std::exception& e) {
21447       {
21448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21449       };
21450     } catch (Dali::DaliException e) {
21451       {
21452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21453       };
21454     } catch (...) {
21455       {
21456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21457       };
21458     }
21459   }
21460
21461   jresult = (unsigned long)result;
21462   return jresult;
21463 }
21464
21465
21466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21467   char * jresult ;
21468   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21469   size_t arg2 ;
21470   std::string result;
21471
21472   arg1 = (Dali::TypeInfo *)jarg1;
21473   arg2 = (size_t)jarg2;
21474   {
21475     try {
21476       result = (arg1)->GetActionName(arg2);
21477     } catch (std::out_of_range& e) {
21478       {
21479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (std::exception& e) {
21482       {
21483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21484       };
21485     } catch (Dali::DaliException e) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21488       };
21489     } catch (...) {
21490       {
21491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21492       };
21493     }
21494   }
21495
21496   jresult = SWIG_csharp_string_callback((&result)->c_str());
21497   return jresult;
21498 }
21499
21500
21501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21502   unsigned long jresult ;
21503   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21504   size_t result;
21505
21506   arg1 = (Dali::TypeInfo *)jarg1;
21507   {
21508     try {
21509       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21510     } catch (std::out_of_range& e) {
21511       {
21512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21513       };
21514     } catch (std::exception& e) {
21515       {
21516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21517       };
21518     } catch (Dali::DaliException e) {
21519       {
21520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21521       };
21522     } catch (...) {
21523       {
21524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21525       };
21526     }
21527   }
21528
21529   jresult = (unsigned long)result;
21530   return jresult;
21531 }
21532
21533
21534 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21535   char * jresult ;
21536   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21537   size_t arg2 ;
21538   std::string result;
21539
21540   arg1 = (Dali::TypeInfo *)jarg1;
21541   arg2 = (size_t)jarg2;
21542   {
21543     try {
21544       result = (arg1)->GetSignalName(arg2);
21545     } catch (std::out_of_range& e) {
21546       {
21547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21548       };
21549     } catch (std::exception& e) {
21550       {
21551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21552       };
21553     } catch (Dali::DaliException e) {
21554       {
21555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21556       };
21557     } catch (...) {
21558       {
21559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21560       };
21561     }
21562   }
21563
21564   jresult = SWIG_csharp_string_callback((&result)->c_str());
21565   return jresult;
21566 }
21567
21568
21569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21570   unsigned long jresult ;
21571   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21572   size_t result;
21573
21574   arg1 = (Dali::TypeInfo *)jarg1;
21575   {
21576     try {
21577       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21578     } catch (std::out_of_range& e) {
21579       {
21580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21581       };
21582     } catch (std::exception& e) {
21583       {
21584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21585       };
21586     } catch (Dali::DaliException e) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21589       };
21590     } catch (...) {
21591       {
21592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21593       };
21594     }
21595   }
21596
21597   jresult = (unsigned long)result;
21598   return jresult;
21599 }
21600
21601
21602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21603   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21604   Dali::Property::IndexContainer *arg2 = 0 ;
21605
21606   arg1 = (Dali::TypeInfo *)jarg1;
21607   arg2 = (Dali::Property::IndexContainer *)jarg2;
21608   if (!arg2) {
21609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21610     return ;
21611   }
21612   {
21613     try {
21614       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21615     } catch (std::out_of_range& e) {
21616       {
21617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21618       };
21619     } catch (std::exception& e) {
21620       {
21621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21622       };
21623     } catch (Dali::DaliException e) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21626       };
21627     } catch (...) {
21628       {
21629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21630       };
21631     }
21632   }
21633
21634 }
21635
21636
21637 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21638   char * jresult ;
21639   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21640   Dali::Property::Index arg2 ;
21641   std::string *result = 0 ;
21642
21643   arg1 = (Dali::TypeInfo *)jarg1;
21644   arg2 = (Dali::Property::Index)jarg2;
21645   {
21646     try {
21647       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21648     } catch (std::out_of_range& e) {
21649       {
21650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21651       };
21652     } catch (std::exception& e) {
21653       {
21654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21655       };
21656     } catch (Dali::DaliException e) {
21657       {
21658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21659       };
21660     } catch (...) {
21661       {
21662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21663       };
21664     }
21665   }
21666
21667   jresult = SWIG_csharp_string_callback(result->c_str());
21668   return jresult;
21669 }
21670
21671
21672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21673   void * jresult ;
21674   Dali::TypeRegistry result;
21675
21676   {
21677     try {
21678       result = Dali::TypeRegistry::Get();
21679     } catch (std::out_of_range& e) {
21680       {
21681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21682       };
21683     } catch (std::exception& e) {
21684       {
21685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21686       };
21687     } catch (Dali::DaliException e) {
21688       {
21689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21690       };
21691     } catch (...) {
21692       {
21693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21694       };
21695     }
21696   }
21697
21698   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21699   return jresult;
21700 }
21701
21702
21703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21704   void * jresult ;
21705   Dali::TypeRegistry *result = 0 ;
21706
21707   {
21708     try {
21709       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21710     } catch (std::out_of_range& e) {
21711       {
21712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (std::exception& e) {
21715       {
21716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21717       };
21718     } catch (Dali::DaliException e) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21721       };
21722     } catch (...) {
21723       {
21724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21725       };
21726     }
21727   }
21728
21729   jresult = (void *)result;
21730   return jresult;
21731 }
21732
21733
21734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21735   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21736
21737   arg1 = (Dali::TypeRegistry *)jarg1;
21738   {
21739     try {
21740       delete arg1;
21741     } catch (std::out_of_range& e) {
21742       {
21743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21744       };
21745     } catch (std::exception& e) {
21746       {
21747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21748       };
21749     } catch (Dali::DaliException e) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21756       };
21757     }
21758   }
21759
21760 }
21761
21762
21763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21764   void * jresult ;
21765   Dali::TypeRegistry *arg1 = 0 ;
21766   Dali::TypeRegistry *result = 0 ;
21767
21768   arg1 = (Dali::TypeRegistry *)jarg1;
21769   if (!arg1) {
21770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21771     return 0;
21772   }
21773   {
21774     try {
21775       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21776     } catch (std::out_of_range& e) {
21777       {
21778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21779       };
21780     } catch (std::exception& e) {
21781       {
21782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21783       };
21784     } catch (Dali::DaliException e) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21787       };
21788     } catch (...) {
21789       {
21790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21791       };
21792     }
21793   }
21794
21795   jresult = (void *)result;
21796   return jresult;
21797 }
21798
21799
21800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21801   void * jresult ;
21802   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21803   Dali::TypeRegistry *arg2 = 0 ;
21804   Dali::TypeRegistry *result = 0 ;
21805
21806   arg1 = (Dali::TypeRegistry *)jarg1;
21807   arg2 = (Dali::TypeRegistry *)jarg2;
21808   if (!arg2) {
21809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21810     return 0;
21811   }
21812   {
21813     try {
21814       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21815     } catch (std::out_of_range& e) {
21816       {
21817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21818       };
21819     } catch (std::exception& e) {
21820       {
21821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21822       };
21823     } catch (Dali::DaliException e) {
21824       {
21825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21826       };
21827     } catch (...) {
21828       {
21829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21830       };
21831     }
21832   }
21833
21834   jresult = (void *)result;
21835   return jresult;
21836 }
21837
21838
21839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21840   void * jresult ;
21841   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21842   std::string *arg2 = 0 ;
21843   Dali::TypeInfo result;
21844
21845   arg1 = (Dali::TypeRegistry *)jarg1;
21846   if (!jarg2) {
21847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21848     return 0;
21849   }
21850   std::string arg2_str(jarg2);
21851   arg2 = &arg2_str;
21852   {
21853     try {
21854       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21855     } catch (std::out_of_range& e) {
21856       {
21857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (std::exception& e) {
21860       {
21861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21862       };
21863     } catch (Dali::DaliException e) {
21864       {
21865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21866       };
21867     } catch (...) {
21868       {
21869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21870       };
21871     }
21872   }
21873
21874   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21875
21876   //argout typemap for const std::string&
21877
21878   return jresult;
21879 }
21880
21881
21882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21883   void * jresult ;
21884   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21885   std::type_info *arg2 = 0 ;
21886   Dali::TypeInfo result;
21887
21888   arg1 = (Dali::TypeRegistry *)jarg1;
21889   arg2 = (std::type_info *)jarg2;
21890   if (!arg2) {
21891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21892     return 0;
21893   }
21894   {
21895     try {
21896       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21897     } catch (std::out_of_range& e) {
21898       {
21899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21900       };
21901     } catch (std::exception& e) {
21902       {
21903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21904       };
21905     } catch (Dali::DaliException e) {
21906       {
21907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21908       };
21909     } catch (...) {
21910       {
21911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21912       };
21913     }
21914   }
21915
21916   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21922   unsigned long jresult ;
21923   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21924   size_t result;
21925
21926   arg1 = (Dali::TypeRegistry *)jarg1;
21927   {
21928     try {
21929       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21930     } catch (std::out_of_range& e) {
21931       {
21932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21933       };
21934     } catch (std::exception& e) {
21935       {
21936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21937       };
21938     } catch (Dali::DaliException e) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21941       };
21942     } catch (...) {
21943       {
21944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21945       };
21946     }
21947   }
21948
21949   jresult = (unsigned long)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21955   char * jresult ;
21956   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21957   size_t arg2 ;
21958   std::string result;
21959
21960   arg1 = (Dali::TypeRegistry *)jarg1;
21961   arg2 = (size_t)jarg2;
21962   {
21963     try {
21964       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21965     } catch (std::out_of_range& e) {
21966       {
21967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (std::exception& e) {
21970       {
21971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (Dali::DaliException e) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21976       };
21977     } catch (...) {
21978       {
21979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21980       };
21981     }
21982   }
21983
21984   jresult = SWIG_csharp_string_callback((&result)->c_str());
21985   return jresult;
21986 }
21987
21988
21989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21990   void * jresult ;
21991   std::type_info *arg1 = 0 ;
21992   std::type_info *arg2 = 0 ;
21993   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21994   Dali::TypeRegistration *result = 0 ;
21995
21996   arg1 = (std::type_info *)jarg1;
21997   if (!arg1) {
21998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21999     return 0;
22000   }
22001   arg2 = (std::type_info *)jarg2;
22002   if (!arg2) {
22003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22004     return 0;
22005   }
22006   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22007   {
22008     try {
22009       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22010     } catch (std::out_of_range& e) {
22011       {
22012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22013       };
22014     } catch (std::exception& e) {
22015       {
22016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22017       };
22018     } catch (Dali::DaliException e) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22021       };
22022     } catch (...) {
22023       {
22024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22025       };
22026     }
22027   }
22028
22029   jresult = (void *)result;
22030   return jresult;
22031 }
22032
22033
22034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22035   void * jresult ;
22036   std::type_info *arg1 = 0 ;
22037   std::type_info *arg2 = 0 ;
22038   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22039   bool arg4 ;
22040   Dali::TypeRegistration *result = 0 ;
22041
22042   arg1 = (std::type_info *)jarg1;
22043   if (!arg1) {
22044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22045     return 0;
22046   }
22047   arg2 = (std::type_info *)jarg2;
22048   if (!arg2) {
22049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22050     return 0;
22051   }
22052   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22053   arg4 = jarg4 ? true : false;
22054   {
22055     try {
22056       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22057     } catch (std::out_of_range& e) {
22058       {
22059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (std::exception& e) {
22062       {
22063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22064       };
22065     } catch (Dali::DaliException e) {
22066       {
22067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22072       };
22073     }
22074   }
22075
22076   jresult = (void *)result;
22077   return jresult;
22078 }
22079
22080
22081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22082   void * jresult ;
22083   std::string *arg1 = 0 ;
22084   std::type_info *arg2 = 0 ;
22085   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22086   Dali::TypeRegistration *result = 0 ;
22087
22088   if (!jarg1) {
22089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22090     return 0;
22091   }
22092   std::string arg1_str(jarg1);
22093   arg1 = &arg1_str;
22094   arg2 = (std::type_info *)jarg2;
22095   if (!arg2) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22097     return 0;
22098   }
22099   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22100   {
22101     try {
22102       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22103     } catch (std::out_of_range& e) {
22104       {
22105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22106       };
22107     } catch (std::exception& e) {
22108       {
22109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22110       };
22111     } catch (Dali::DaliException e) {
22112       {
22113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22114       };
22115     } catch (...) {
22116       {
22117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22118       };
22119     }
22120   }
22121
22122   jresult = (void *)result;
22123
22124   //argout typemap for const std::string&
22125
22126   return jresult;
22127 }
22128
22129
22130 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22131   char * jresult ;
22132   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22133   std::string result;
22134
22135   arg1 = (Dali::TypeRegistration *)jarg1;
22136   {
22137     try {
22138       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22139     } catch (std::out_of_range& e) {
22140       {
22141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22142       };
22143     } catch (std::exception& e) {
22144       {
22145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22146       };
22147     } catch (Dali::DaliException e) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22150       };
22151     } catch (...) {
22152       {
22153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22154       };
22155     }
22156   }
22157
22158   jresult = SWIG_csharp_string_callback((&result)->c_str());
22159   return jresult;
22160 }
22161
22162
22163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22164   std::string *arg1 = 0 ;
22165   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22166
22167   if (!jarg1) {
22168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22169     return ;
22170   }
22171   std::string arg1_str(jarg1);
22172   arg1 = &arg1_str;
22173   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22174   {
22175     try {
22176       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22177     } catch (std::out_of_range& e) {
22178       {
22179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22180       };
22181     } catch (std::exception& e) {
22182       {
22183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22184       };
22185     } catch (Dali::DaliException e) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22188       };
22189     } catch (...) {
22190       {
22191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22192       };
22193     }
22194   }
22195
22196
22197   //argout typemap for const std::string&
22198
22199 }
22200
22201
22202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22203   std::string *arg1 = 0 ;
22204   std::string *arg2 = 0 ;
22205   int arg3 ;
22206   Dali::Property::Type arg4 ;
22207   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22208   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22209
22210   if (!jarg1) {
22211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22212     return ;
22213   }
22214   std::string arg1_str(jarg1);
22215   arg1 = &arg1_str;
22216   if (!jarg2) {
22217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22218     return ;
22219   }
22220   std::string arg2_str(jarg2);
22221   arg2 = &arg2_str;
22222   arg3 = (int)jarg3;
22223   arg4 = (Dali::Property::Type)jarg4;
22224   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22225   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22226   {
22227     try {
22228       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22236       };
22237     } catch (Dali::DaliException e) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22240       };
22241     } catch (...) {
22242       {
22243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22244       };
22245     }
22246   }
22247
22248
22249   //argout typemap for const std::string&
22250
22251
22252   //argout typemap for const std::string&
22253
22254 }
22255
22256
22257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22258   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22259
22260   arg1 = (Dali::TypeRegistration *)jarg1;
22261   {
22262     try {
22263       delete arg1;
22264     } catch (std::out_of_range& e) {
22265       {
22266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (std::exception& e) {
22269       {
22270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22271       };
22272     } catch (Dali::DaliException e) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22275       };
22276     } catch (...) {
22277       {
22278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22279       };
22280     }
22281   }
22282
22283 }
22284
22285
22286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22287   void * jresult ;
22288   Dali::TypeRegistration *arg1 = 0 ;
22289   std::string *arg2 = 0 ;
22290   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22291   Dali::SignalConnectorType *result = 0 ;
22292
22293   arg1 = (Dali::TypeRegistration *)jarg1;
22294   if (!arg1) {
22295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22296     return 0;
22297   }
22298   if (!jarg2) {
22299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22300     return 0;
22301   }
22302   std::string arg2_str(jarg2);
22303   arg2 = &arg2_str;
22304   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22305   {
22306     try {
22307       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22308     } catch (std::out_of_range& e) {
22309       {
22310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22311       };
22312     } catch (std::exception& e) {
22313       {
22314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22315       };
22316     } catch (Dali::DaliException e) {
22317       {
22318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22319       };
22320     } catch (...) {
22321       {
22322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22323       };
22324     }
22325   }
22326
22327   jresult = (void *)result;
22328
22329   //argout typemap for const std::string&
22330
22331   return jresult;
22332 }
22333
22334
22335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22336   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22337
22338   arg1 = (Dali::SignalConnectorType *)jarg1;
22339   {
22340     try {
22341       delete arg1;
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22349       };
22350     } catch (Dali::DaliException e) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22353       };
22354     } catch (...) {
22355       {
22356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22357       };
22358     }
22359   }
22360
22361 }
22362
22363
22364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22365   void * jresult ;
22366   Dali::TypeRegistration *arg1 = 0 ;
22367   std::string *arg2 = 0 ;
22368   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22369   Dali::TypeAction *result = 0 ;
22370
22371   arg1 = (Dali::TypeRegistration *)jarg1;
22372   if (!arg1) {
22373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22374     return 0;
22375   }
22376   if (!jarg2) {
22377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22378     return 0;
22379   }
22380   std::string arg2_str(jarg2);
22381   arg2 = &arg2_str;
22382   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22383   {
22384     try {
22385       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22386     } catch (std::out_of_range& e) {
22387       {
22388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22389       };
22390     } catch (std::exception& e) {
22391       {
22392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22393       };
22394     } catch (Dali::DaliException e) {
22395       {
22396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22397       };
22398     } catch (...) {
22399       {
22400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22401       };
22402     }
22403   }
22404
22405   jresult = (void *)result;
22406
22407   //argout typemap for const std::string&
22408
22409   return jresult;
22410 }
22411
22412
22413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22414   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22415
22416   arg1 = (Dali::TypeAction *)jarg1;
22417   {
22418     try {
22419       delete arg1;
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22427       };
22428     } catch (Dali::DaliException e) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22431       };
22432     } catch (...) {
22433       {
22434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22435       };
22436     }
22437   }
22438
22439 }
22440
22441
22442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22443   void * jresult ;
22444   Dali::TypeRegistration *arg1 = 0 ;
22445   std::string *arg2 = 0 ;
22446   Dali::Property::Index arg3 ;
22447   Dali::Property::Type arg4 ;
22448   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22449   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22450   Dali::PropertyRegistration *result = 0 ;
22451
22452   arg1 = (Dali::TypeRegistration *)jarg1;
22453   if (!arg1) {
22454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22455     return 0;
22456   }
22457   if (!jarg2) {
22458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22459     return 0;
22460   }
22461   std::string arg2_str(jarg2);
22462   arg2 = &arg2_str;
22463   arg3 = (Dali::Property::Index)jarg3;
22464   arg4 = (Dali::Property::Type)jarg4;
22465   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22466   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22467   {
22468     try {
22469       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22470     } catch (std::out_of_range& e) {
22471       {
22472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22473       };
22474     } catch (std::exception& e) {
22475       {
22476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22477       };
22478     } catch (Dali::DaliException e) {
22479       {
22480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22481       };
22482     } catch (...) {
22483       {
22484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22485       };
22486     }
22487   }
22488
22489   jresult = (void *)result;
22490
22491   //argout typemap for const std::string&
22492
22493   return jresult;
22494 }
22495
22496
22497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22498   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22499
22500   arg1 = (Dali::PropertyRegistration *)jarg1;
22501   {
22502     try {
22503       delete arg1;
22504     } catch (std::out_of_range& e) {
22505       {
22506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22507       };
22508     } catch (std::exception& e) {
22509       {
22510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22511       };
22512     } catch (Dali::DaliException e) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22515       };
22516     } catch (...) {
22517       {
22518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22519       };
22520     }
22521   }
22522
22523 }
22524
22525
22526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22527   void * jresult ;
22528   Dali::TypeRegistration *arg1 = 0 ;
22529   std::string *arg2 = 0 ;
22530   Dali::Property::Index arg3 ;
22531   Dali::Property::Type arg4 ;
22532   Dali::AnimatablePropertyRegistration *result = 0 ;
22533
22534   arg1 = (Dali::TypeRegistration *)jarg1;
22535   if (!arg1) {
22536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22537     return 0;
22538   }
22539   if (!jarg2) {
22540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22541     return 0;
22542   }
22543   std::string arg2_str(jarg2);
22544   arg2 = &arg2_str;
22545   arg3 = (Dali::Property::Index)jarg3;
22546   arg4 = (Dali::Property::Type)jarg4;
22547   {
22548     try {
22549       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22550     } catch (std::out_of_range& e) {
22551       {
22552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22553       };
22554     } catch (std::exception& e) {
22555       {
22556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22557       };
22558     } catch (Dali::DaliException e) {
22559       {
22560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22561       };
22562     } catch (...) {
22563       {
22564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22565       };
22566     }
22567   }
22568
22569   jresult = (void *)result;
22570
22571   //argout typemap for const std::string&
22572
22573   return jresult;
22574 }
22575
22576
22577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22578   void * jresult ;
22579   Dali::TypeRegistration *arg1 = 0 ;
22580   std::string *arg2 = 0 ;
22581   Dali::Property::Index arg3 ;
22582   Dali::Property::Value *arg4 = 0 ;
22583   Dali::AnimatablePropertyRegistration *result = 0 ;
22584
22585   arg1 = (Dali::TypeRegistration *)jarg1;
22586   if (!arg1) {
22587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22588     return 0;
22589   }
22590   if (!jarg2) {
22591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22592     return 0;
22593   }
22594   std::string arg2_str(jarg2);
22595   arg2 = &arg2_str;
22596   arg3 = (Dali::Property::Index)jarg3;
22597   arg4 = (Dali::Property::Value *)jarg4;
22598   if (!arg4) {
22599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22600     return 0;
22601   }
22602   {
22603     try {
22604       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22605     } catch (std::out_of_range& e) {
22606       {
22607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (std::exception& e) {
22610       {
22611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22612       };
22613     } catch (Dali::DaliException e) {
22614       {
22615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22616       };
22617     } catch (...) {
22618       {
22619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22620       };
22621     }
22622   }
22623
22624   jresult = (void *)result;
22625
22626   //argout typemap for const std::string&
22627
22628   return jresult;
22629 }
22630
22631
22632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22633   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22634
22635   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22636   {
22637     try {
22638       delete arg1;
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22646       };
22647     } catch (Dali::DaliException e) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22650       };
22651     } catch (...) {
22652       {
22653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22654       };
22655     }
22656   }
22657
22658 }
22659
22660
22661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22662   void * jresult ;
22663   Dali::TypeRegistration *arg1 = 0 ;
22664   std::string *arg2 = 0 ;
22665   Dali::Property::Index arg3 ;
22666   Dali::Property::Index arg4 ;
22667   unsigned int arg5 ;
22668   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22669
22670   arg1 = (Dali::TypeRegistration *)jarg1;
22671   if (!arg1) {
22672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22673     return 0;
22674   }
22675   if (!jarg2) {
22676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22677     return 0;
22678   }
22679   std::string arg2_str(jarg2);
22680   arg2 = &arg2_str;
22681   arg3 = (Dali::Property::Index)jarg3;
22682   arg4 = (Dali::Property::Index)jarg4;
22683   arg5 = (unsigned int)jarg5;
22684   {
22685     try {
22686       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22687     } catch (std::out_of_range& e) {
22688       {
22689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (std::exception& e) {
22692       {
22693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22694       };
22695     } catch (Dali::DaliException e) {
22696       {
22697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22698       };
22699     } catch (...) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22702       };
22703     }
22704   }
22705
22706   jresult = (void *)result;
22707
22708   //argout typemap for const std::string&
22709
22710   return jresult;
22711 }
22712
22713
22714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22715   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22716
22717   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22718   {
22719     try {
22720       delete arg1;
22721     } catch (std::out_of_range& e) {
22722       {
22723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22724       };
22725     } catch (std::exception& e) {
22726       {
22727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22728       };
22729     } catch (Dali::DaliException e) {
22730       {
22731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22732       };
22733     } catch (...) {
22734       {
22735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22736       };
22737     }
22738   }
22739
22740 }
22741
22742
22743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22744   void * jresult ;
22745   Dali::TypeRegistration *arg1 = 0 ;
22746   std::string *arg2 = 0 ;
22747   Dali::Property::Index arg3 ;
22748   Dali::Property::Type arg4 ;
22749   Dali::ChildPropertyRegistration *result = 0 ;
22750
22751   arg1 = (Dali::TypeRegistration *)jarg1;
22752   if (!arg1) {
22753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22754     return 0;
22755   }
22756   if (!jarg2) {
22757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22758     return 0;
22759   }
22760   std::string arg2_str(jarg2);
22761   arg2 = &arg2_str;
22762   arg3 = (Dali::Property::Index)jarg3;
22763   arg4 = (Dali::Property::Type)jarg4;
22764   {
22765     try {
22766       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (Dali::DaliException e) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22778       };
22779     } catch (...) {
22780       {
22781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22782       };
22783     }
22784   }
22785
22786   jresult = (void *)result;
22787
22788   //argout typemap for const std::string&
22789
22790   return jresult;
22791 }
22792
22793
22794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22795   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22796
22797   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22798   {
22799     try {
22800       delete arg1;
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22808       };
22809     } catch (Dali::DaliException e) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22812       };
22813     } catch (...) {
22814       {
22815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22816       };
22817     }
22818   }
22819
22820 }
22821
22822
22823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22824   unsigned int jresult ;
22825   std::string *arg1 = 0 ;
22826   std::type_info *arg2 = 0 ;
22827   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22828   bool result;
22829
22830   if (!jarg1) {
22831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22832     return 0;
22833   }
22834   std::string arg1_str(jarg1);
22835   arg1 = &arg1_str;
22836   arg2 = (std::type_info *)jarg2;
22837   if (!arg2) {
22838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22839     return 0;
22840   }
22841   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22842   {
22843     try {
22844       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22845     } catch (std::out_of_range& e) {
22846       {
22847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22848       };
22849     } catch (std::exception& e) {
22850       {
22851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22852       };
22853     } catch (Dali::DaliException e) {
22854       {
22855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22856       };
22857     } catch (...) {
22858       {
22859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22860       };
22861     }
22862   }
22863
22864   jresult = result;
22865
22866   //argout typemap for const std::string&
22867
22868   return jresult;
22869 }
22870
22871
22872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22873   unsigned int jresult ;
22874   std::string *arg1 = 0 ;
22875   std::string *arg2 = 0 ;
22876   Dali::Property::Index arg3 ;
22877   Dali::Property::Type arg4 ;
22878   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22879   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22880   bool result;
22881
22882   if (!jarg1) {
22883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22884     return 0;
22885   }
22886   std::string arg1_str(jarg1);
22887   arg1 = &arg1_str;
22888   if (!jarg2) {
22889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22890     return 0;
22891   }
22892   std::string arg2_str(jarg2);
22893   arg2 = &arg2_str;
22894   arg3 = (Dali::Property::Index)jarg3;
22895   arg4 = (Dali::Property::Type)jarg4;
22896   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22897   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22898   {
22899     try {
22900       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22901     } catch (std::out_of_range& e) {
22902       {
22903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (std::exception& e) {
22906       {
22907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22908       };
22909     } catch (Dali::DaliException e) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22912       };
22913     } catch (...) {
22914       {
22915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22916       };
22917     }
22918   }
22919
22920   jresult = result;
22921
22922   //argout typemap for const std::string&
22923
22924
22925   //argout typemap for const std::string&
22926
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::TOP;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::LEFT;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22962   float jresult ;
22963   float result;
22964
22965   result = (float)(float)Dali::ParentOrigin::RIGHT;
22966   jresult = result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22972   float jresult ;
22973   float result;
22974
22975   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22976   jresult = result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23052   void * jresult ;
23053   Dali::Vector3 *result = 0 ;
23054
23055   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23056   jresult = (void *)result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23062   void * jresult ;
23063   Dali::Vector3 *result = 0 ;
23064
23065   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23066   jresult = (void *)result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::TOP;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::LEFT;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23102   float jresult ;
23103   float result;
23104
23105   result = (float)(float)Dali::AnchorPoint::RIGHT;
23106   jresult = result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23112   float jresult ;
23113   float result;
23114
23115   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23116   jresult = result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23192   void * jresult ;
23193   Dali::Vector3 *result = 0 ;
23194
23195   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23202   void * jresult ;
23203   Dali::Vector3 *result = 0 ;
23204
23205   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::RED;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23282   void * jresult ;
23283   Dali::Vector4 *result = 0 ;
23284
23285   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23286   jresult = (void *)result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23292   void * jresult ;
23293   Dali::Vector4 *result = 0 ;
23294
23295   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23296   jresult = (void *)result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_2;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::PI_4;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23392   float jresult ;
23393   float result;
23394
23395   result = (float)(float)Dali::Math::PI_OVER_180;
23396   jresult = result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23402   float jresult ;
23403   float result;
23404
23405   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23406   jresult = result;
23407   return jresult;
23408 }
23409
23410
23411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23412   int jresult ;
23413   Dali::ResizePolicy::Type result;
23414
23415   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23416   jresult = (int)result;
23417   return jresult;
23418 }
23419
23420
23421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23422   unsigned long jresult ;
23423   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23424   Dali::VectorBase::SizeType result;
23425
23426   arg1 = (Dali::VectorBase *)jarg1;
23427   {
23428     try {
23429       result = ((Dali::VectorBase const *)arg1)->Count();
23430     } catch (std::out_of_range& e) {
23431       {
23432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23433       };
23434     } catch (std::exception& e) {
23435       {
23436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23437       };
23438     } catch (Dali::DaliException e) {
23439       {
23440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23441       };
23442     } catch (...) {
23443       {
23444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23445       };
23446     }
23447   }
23448
23449   jresult = (unsigned long)result;
23450   return jresult;
23451 }
23452
23453
23454 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23455   unsigned long jresult ;
23456   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23457   Dali::VectorBase::SizeType result;
23458
23459   arg1 = (Dali::VectorBase *)jarg1;
23460   {
23461     try {
23462       result = ((Dali::VectorBase const *)arg1)->Size();
23463     } catch (std::out_of_range& e) {
23464       {
23465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23466       };
23467     } catch (std::exception& e) {
23468       {
23469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23470       };
23471     } catch (Dali::DaliException e) {
23472       {
23473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23474       };
23475     } catch (...) {
23476       {
23477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23478       };
23479     }
23480   }
23481
23482   jresult = (unsigned long)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23488   unsigned int jresult ;
23489   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23490   bool result;
23491
23492   arg1 = (Dali::VectorBase *)jarg1;
23493   {
23494     try {
23495       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23496     } catch (std::out_of_range& e) {
23497       {
23498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23499       };
23500     } catch (std::exception& e) {
23501       {
23502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23503       };
23504     } catch (Dali::DaliException e) {
23505       {
23506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23507       };
23508     } catch (...) {
23509       {
23510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23511       };
23512     }
23513   }
23514
23515   jresult = result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23521   unsigned long jresult ;
23522   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23523   Dali::VectorBase::SizeType result;
23524
23525   arg1 = (Dali::VectorBase *)jarg1;
23526   {
23527     try {
23528       result = ((Dali::VectorBase const *)arg1)->Capacity();
23529     } catch (std::out_of_range& e) {
23530       {
23531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23532       };
23533     } catch (std::exception& e) {
23534       {
23535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23536       };
23537     } catch (Dali::DaliException e) {
23538       {
23539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23540       };
23541     } catch (...) {
23542       {
23543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23544       };
23545     }
23546   }
23547
23548   jresult = (unsigned long)result;
23549   return jresult;
23550 }
23551
23552
23553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23554   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23555
23556   arg1 = (Dali::VectorBase *)jarg1;
23557   {
23558     try {
23559       (arg1)->Release();
23560     } catch (std::out_of_range& e) {
23561       {
23562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23563       };
23564     } catch (std::exception& e) {
23565       {
23566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23567       };
23568     } catch (Dali::DaliException e) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23571       };
23572     } catch (...) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23575       };
23576     }
23577   }
23578
23579 }
23580
23581
23582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23583   int jresult ;
23584   Dali::Pixel::Format result;
23585
23586   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23587   jresult = (int)result;
23588   return jresult;
23589 }
23590
23591
23592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23593   int jresult ;
23594   Dali::Pixel::Format result;
23595
23596   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23597   jresult = (int)result;
23598   return jresult;
23599 }
23600
23601
23602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23603   unsigned int jresult ;
23604   Dali::Pixel::Format arg1 ;
23605   bool result;
23606
23607   arg1 = (Dali::Pixel::Format)jarg1;
23608   {
23609     try {
23610       result = (bool)Dali::Pixel::HasAlpha(arg1);
23611     } catch (std::out_of_range& e) {
23612       {
23613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (std::exception& e) {
23616       {
23617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23618       };
23619     } catch (Dali::DaliException e) {
23620       {
23621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23622       };
23623     } catch (...) {
23624       {
23625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23626       };
23627     }
23628   }
23629
23630   jresult = result;
23631   return jresult;
23632 }
23633
23634
23635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23636   unsigned int jresult ;
23637   Dali::Pixel::Format arg1 ;
23638   unsigned int result;
23639
23640   arg1 = (Dali::Pixel::Format)jarg1;
23641   {
23642     try {
23643       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23644     } catch (std::out_of_range& e) {
23645       {
23646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23647       };
23648     } catch (std::exception& e) {
23649       {
23650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23651       };
23652     } catch (Dali::DaliException e) {
23653       {
23654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23655       };
23656     } catch (...) {
23657       {
23658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23659       };
23660     }
23661   }
23662
23663   jresult = result;
23664   return jresult;
23665 }
23666
23667
23668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23669   Dali::Pixel::Format arg1 ;
23670   int *arg2 = 0 ;
23671   int *arg3 = 0 ;
23672
23673   arg1 = (Dali::Pixel::Format)jarg1;
23674   arg2 = (int *)jarg2;
23675   if (!arg2) {
23676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23677     return ;
23678   }
23679   arg3 = (int *)jarg3;
23680   if (!arg3) {
23681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23682     return ;
23683   }
23684   {
23685     try {
23686       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23687     } catch (std::out_of_range& e) {
23688       {
23689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23690       };
23691     } catch (std::exception& e) {
23692       {
23693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23694       };
23695     } catch (Dali::DaliException e) {
23696       {
23697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23698       };
23699     } catch (...) {
23700       {
23701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23702       };
23703     }
23704   }
23705
23706 }
23707
23708
23709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23710   void * jresult ;
23711   unsigned char *arg1 = (unsigned char *) 0 ;
23712   unsigned int arg2 ;
23713   unsigned int arg3 ;
23714   unsigned int arg4 ;
23715   Dali::Pixel::Format arg5 ;
23716   Dali::PixelData::ReleaseFunction arg6 ;
23717   Dali::PixelData result;
23718
23719   arg1 = jarg1;
23720   arg2 = (unsigned int)jarg2;
23721   arg3 = (unsigned int)jarg3;
23722   arg4 = (unsigned int)jarg4;
23723   arg5 = (Dali::Pixel::Format)jarg5;
23724   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23725   {
23726     try {
23727       auto pixelBuffer = new unsigned char[jarg2];
23728       memcpy( pixelBuffer, arg1, arg2);
23729       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23730     } catch (std::out_of_range& e) {
23731       {
23732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23733       };
23734     } catch (std::exception& e) {
23735       {
23736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23737       };
23738     } catch (Dali::DaliException e) {
23739       {
23740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23741       };
23742     } catch (...) {
23743       {
23744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23745       };
23746     }
23747   }
23748
23749   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23750
23751
23752   return jresult;
23753 }
23754
23755
23756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23757   void * jresult ;
23758   Dali::PixelData *result = 0 ;
23759
23760   {
23761     try {
23762       result = (Dali::PixelData *)new Dali::PixelData();
23763     } catch (std::out_of_range& e) {
23764       {
23765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23766       };
23767     } catch (std::exception& e) {
23768       {
23769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23770       };
23771     } catch (Dali::DaliException e) {
23772       {
23773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23774       };
23775     } catch (...) {
23776       {
23777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23778       };
23779     }
23780   }
23781
23782   jresult = (void *)result;
23783   return jresult;
23784 }
23785
23786
23787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23788   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23789
23790   arg1 = (Dali::PixelData *)jarg1;
23791   {
23792     try {
23793       delete arg1;
23794     } catch (std::out_of_range& e) {
23795       {
23796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23797       };
23798     } catch (std::exception& e) {
23799       {
23800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23801       };
23802     } catch (Dali::DaliException e) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23805       };
23806     } catch (...) {
23807       {
23808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23809       };
23810     }
23811   }
23812
23813 }
23814
23815
23816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23817   void * jresult ;
23818   Dali::PixelData *arg1 = 0 ;
23819   Dali::PixelData *result = 0 ;
23820
23821   arg1 = (Dali::PixelData *)jarg1;
23822   if (!arg1) {
23823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23824     return 0;
23825   }
23826   {
23827     try {
23828       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23829     } catch (std::out_of_range& e) {
23830       {
23831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23832       };
23833     } catch (std::exception& e) {
23834       {
23835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23836       };
23837     } catch (Dali::DaliException e) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23840       };
23841     } catch (...) {
23842       {
23843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23844       };
23845     }
23846   }
23847
23848   jresult = (void *)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23854   void * jresult ;
23855   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23856   Dali::PixelData *arg2 = 0 ;
23857   Dali::PixelData *result = 0 ;
23858
23859   arg1 = (Dali::PixelData *)jarg1;
23860   arg2 = (Dali::PixelData *)jarg2;
23861   if (!arg2) {
23862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23863     return 0;
23864   }
23865   {
23866     try {
23867       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23868     } catch (std::out_of_range& e) {
23869       {
23870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23871       };
23872     } catch (std::exception& e) {
23873       {
23874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23875       };
23876     } catch (Dali::DaliException e) {
23877       {
23878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23879       };
23880     } catch (...) {
23881       {
23882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23883       };
23884     }
23885   }
23886
23887   jresult = (void *)result;
23888   return jresult;
23889 }
23890
23891
23892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23893   unsigned int jresult ;
23894   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23895   unsigned int result;
23896
23897   arg1 = (Dali::PixelData *)jarg1;
23898   {
23899     try {
23900       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23901     } catch (std::out_of_range& e) {
23902       {
23903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (std::exception& e) {
23906       {
23907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23908       };
23909     } catch (Dali::DaliException e) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23912       };
23913     } catch (...) {
23914       {
23915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23916       };
23917     }
23918   }
23919
23920   jresult = result;
23921   return jresult;
23922 }
23923
23924
23925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23926   unsigned int jresult ;
23927   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23928   unsigned int result;
23929
23930   arg1 = (Dali::PixelData *)jarg1;
23931   {
23932     try {
23933       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23934     } catch (std::out_of_range& e) {
23935       {
23936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23937       };
23938     } catch (std::exception& e) {
23939       {
23940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23941       };
23942     } catch (Dali::DaliException e) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23945       };
23946     } catch (...) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23949       };
23950     }
23951   }
23952
23953   jresult = result;
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23959   int jresult ;
23960   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23961   Dali::Pixel::Format result;
23962
23963   arg1 = (Dali::PixelData *)jarg1;
23964   {
23965     try {
23966       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23967     } catch (std::out_of_range& e) {
23968       {
23969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (std::exception& e) {
23972       {
23973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23974       };
23975     } catch (Dali::DaliException e) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23978       };
23979     } catch (...) {
23980       {
23981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23982       };
23983     }
23984   }
23985
23986   jresult = (int)result;
23987   return jresult;
23988 }
23989
23990
23991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23992   unsigned int jresult ;
23993   unsigned int result;
23994
23995   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23996   jresult = result;
23997   return jresult;
23998 }
23999
24000
24001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24002   unsigned int jresult ;
24003   unsigned int result;
24004
24005   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24006   jresult = result;
24007   return jresult;
24008 }
24009
24010
24011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24012   unsigned int jresult ;
24013   unsigned int result;
24014
24015   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24016   jresult = result;
24017   return jresult;
24018 }
24019
24020
24021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24022   unsigned int jresult ;
24023   unsigned int result;
24024
24025   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24026   jresult = result;
24027   return jresult;
24028 }
24029
24030
24031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24032   unsigned int jresult ;
24033   unsigned int result;
24034
24035   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24036   jresult = result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24042   unsigned int jresult ;
24043   unsigned int result;
24044
24045   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24046   jresult = result;
24047   return jresult;
24048 }
24049
24050
24051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24052   void * jresult ;
24053   Dali::TextureType::Type arg1 ;
24054   Dali::Pixel::Format arg2 ;
24055   unsigned int arg3 ;
24056   unsigned int arg4 ;
24057   Dali::Texture result;
24058
24059   arg1 = (Dali::TextureType::Type)jarg1;
24060   arg2 = (Dali::Pixel::Format)jarg2;
24061   arg3 = (unsigned int)jarg3;
24062   arg4 = (unsigned int)jarg4;
24063   {
24064     try {
24065       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24066     } catch (std::out_of_range& e) {
24067       {
24068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (std::exception& e) {
24071       {
24072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24073       };
24074     } catch (Dali::DaliException e) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24077       };
24078     } catch (...) {
24079       {
24080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24081       };
24082     }
24083   }
24084
24085   jresult = new Dali::Texture((const Dali::Texture &)result);
24086   return jresult;
24087 }
24088
24089
24090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24091   void * jresult ;
24092   NativeImageInterface *arg1 = 0 ;
24093   Dali::Texture result;
24094
24095   arg1 = (NativeImageInterface *)jarg1;
24096   if (!arg1) {
24097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24098     return 0;
24099   }
24100   {
24101     try {
24102       result = Dali::Texture::New(*arg1);
24103     } catch (std::out_of_range& e) {
24104       {
24105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (std::exception& e) {
24108       {
24109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24110       };
24111     } catch (Dali::DaliException e) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24114       };
24115     } catch (...) {
24116       {
24117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24118       };
24119     }
24120   }
24121
24122   jresult = new Dali::Texture((const Dali::Texture &)result);
24123   return jresult;
24124 }
24125
24126
24127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24128   void * jresult ;
24129   Dali::Texture *result = 0 ;
24130
24131   {
24132     try {
24133       result = (Dali::Texture *)new Dali::Texture();
24134     } catch (std::out_of_range& e) {
24135       {
24136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24137       };
24138     } catch (std::exception& e) {
24139       {
24140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24141       };
24142     } catch (Dali::DaliException e) {
24143       {
24144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24145       };
24146     } catch (...) {
24147       {
24148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24149       };
24150     }
24151   }
24152
24153   jresult = (void *)result;
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24159   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24160
24161   arg1 = (Dali::Texture *)jarg1;
24162   {
24163     try {
24164       delete arg1;
24165     } catch (std::out_of_range& e) {
24166       {
24167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24168       };
24169     } catch (std::exception& e) {
24170       {
24171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24172       };
24173     } catch (Dali::DaliException e) {
24174       {
24175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24176       };
24177     } catch (...) {
24178       {
24179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24180       };
24181     }
24182   }
24183
24184 }
24185
24186
24187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24188   void * jresult ;
24189   Dali::Texture *arg1 = 0 ;
24190   Dali::Texture *result = 0 ;
24191
24192   arg1 = (Dali::Texture *)jarg1;
24193   if (!arg1) {
24194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24195     return 0;
24196   }
24197   {
24198     try {
24199       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24200     } catch (std::out_of_range& e) {
24201       {
24202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24203       };
24204     } catch (std::exception& e) {
24205       {
24206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24207       };
24208     } catch (Dali::DaliException e) {
24209       {
24210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24211       };
24212     } catch (...) {
24213       {
24214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24215       };
24216     }
24217   }
24218
24219   jresult = (void *)result;
24220   return jresult;
24221 }
24222
24223
24224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24225   void * jresult ;
24226   Dali::BaseHandle arg1 ;
24227   Dali::BaseHandle *argp1 ;
24228   Dali::Texture result;
24229
24230   argp1 = (Dali::BaseHandle *)jarg1;
24231   if (!argp1) {
24232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24233     return 0;
24234   }
24235   arg1 = *argp1;
24236   {
24237     try {
24238       result = Dali::Texture::DownCast(arg1);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24246       };
24247     } catch (Dali::DaliException e) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24250       };
24251     } catch (...) {
24252       {
24253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24254       };
24255     }
24256   }
24257
24258   jresult = new Dali::Texture((const Dali::Texture &)result);
24259   return jresult;
24260 }
24261
24262
24263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24264   void * jresult ;
24265   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24266   Dali::Texture *arg2 = 0 ;
24267   Dali::Texture *result = 0 ;
24268
24269   arg1 = (Dali::Texture *)jarg1;
24270   arg2 = (Dali::Texture *)jarg2;
24271   if (!arg2) {
24272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24273     return 0;
24274   }
24275   {
24276     try {
24277       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24278     } catch (std::out_of_range& e) {
24279       {
24280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24281       };
24282     } catch (std::exception& e) {
24283       {
24284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24285       };
24286     } catch (Dali::DaliException e) {
24287       {
24288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24293       };
24294     }
24295   }
24296
24297   jresult = (void *)result;
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24303   unsigned int jresult ;
24304   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24305   Dali::PixelData arg2 ;
24306   Dali::PixelData *argp2 ;
24307   bool result;
24308
24309   arg1 = (Dali::Texture *)jarg1;
24310   argp2 = (Dali::PixelData *)jarg2;
24311   if (!argp2) {
24312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24313     return 0;
24314   }
24315   arg2 = *argp2;
24316   {
24317     try {
24318       result = (bool)(arg1)->Upload(arg2);
24319     } catch (std::out_of_range& e) {
24320       {
24321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24322       };
24323     } catch (std::exception& e) {
24324       {
24325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24326       };
24327     } catch (Dali::DaliException e) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24330       };
24331     } catch (...) {
24332       {
24333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24334       };
24335     }
24336   }
24337
24338   jresult = result;
24339   return jresult;
24340 }
24341
24342
24343 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) {
24344   unsigned int jresult ;
24345   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24346   Dali::PixelData arg2 ;
24347   unsigned int arg3 ;
24348   unsigned int arg4 ;
24349   unsigned int arg5 ;
24350   unsigned int arg6 ;
24351   unsigned int arg7 ;
24352   unsigned int arg8 ;
24353   Dali::PixelData *argp2 ;
24354   bool result;
24355
24356   arg1 = (Dali::Texture *)jarg1;
24357   argp2 = (Dali::PixelData *)jarg2;
24358   if (!argp2) {
24359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24360     return 0;
24361   }
24362   arg2 = *argp2;
24363   arg3 = (unsigned int)jarg3;
24364   arg4 = (unsigned int)jarg4;
24365   arg5 = (unsigned int)jarg5;
24366   arg6 = (unsigned int)jarg6;
24367   arg7 = (unsigned int)jarg7;
24368   arg8 = (unsigned int)jarg8;
24369   {
24370     try {
24371       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24372     } catch (std::out_of_range& e) {
24373       {
24374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24375       };
24376     } catch (std::exception& e) {
24377       {
24378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24379       };
24380     } catch (Dali::DaliException e) {
24381       {
24382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24383       };
24384     } catch (...) {
24385       {
24386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24387       };
24388     }
24389   }
24390
24391   jresult = result;
24392   return jresult;
24393 }
24394
24395
24396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24397   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24398
24399   arg1 = (Dali::Texture *)jarg1;
24400   {
24401     try {
24402       (arg1)->GenerateMipmaps();
24403     } catch (std::out_of_range& e) {
24404       {
24405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24406       };
24407     } catch (std::exception& e) {
24408       {
24409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24410       };
24411     } catch (Dali::DaliException e) {
24412       {
24413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24414       };
24415     } catch (...) {
24416       {
24417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24418       };
24419     }
24420   }
24421
24422 }
24423
24424
24425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24426   unsigned int jresult ;
24427   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24428   unsigned int result;
24429
24430   arg1 = (Dali::Texture *)jarg1;
24431   {
24432     try {
24433       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24434     } catch (std::out_of_range& e) {
24435       {
24436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24437       };
24438     } catch (std::exception& e) {
24439       {
24440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24441       };
24442     } catch (Dali::DaliException e) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24445       };
24446     } catch (...) {
24447       {
24448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24449       };
24450     }
24451   }
24452
24453   jresult = result;
24454   return jresult;
24455 }
24456
24457
24458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24459   unsigned int jresult ;
24460   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24461   unsigned int result;
24462
24463   arg1 = (Dali::Texture *)jarg1;
24464   {
24465     try {
24466       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24467     } catch (std::out_of_range& e) {
24468       {
24469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24470       };
24471     } catch (std::exception& e) {
24472       {
24473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24474       };
24475     } catch (Dali::DaliException e) {
24476       {
24477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24478       };
24479     } catch (...) {
24480       {
24481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24482       };
24483     }
24484   }
24485
24486   jresult = result;
24487   return jresult;
24488 }
24489
24490
24491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24492   void * jresult ;
24493   Dali::Sampler result;
24494
24495   {
24496     try {
24497       result = Dali::Sampler::New();
24498     } catch (std::out_of_range& e) {
24499       {
24500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24501       };
24502     } catch (std::exception& e) {
24503       {
24504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24505       };
24506     } catch (Dali::DaliException e) {
24507       {
24508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24509       };
24510     } catch (...) {
24511       {
24512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24513       };
24514     }
24515   }
24516
24517   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24523   void * jresult ;
24524   Dali::Sampler *result = 0 ;
24525
24526   {
24527     try {
24528       result = (Dali::Sampler *)new Dali::Sampler();
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = (void *)result;
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24554   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24555
24556   arg1 = (Dali::Sampler *)jarg1;
24557   {
24558     try {
24559       delete arg1;
24560     } catch (std::out_of_range& e) {
24561       {
24562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24563       };
24564     } catch (std::exception& e) {
24565       {
24566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24567       };
24568     } catch (Dali::DaliException e) {
24569       {
24570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24571       };
24572     } catch (...) {
24573       {
24574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24575       };
24576     }
24577   }
24578
24579 }
24580
24581
24582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24583   void * jresult ;
24584   Dali::Sampler *arg1 = 0 ;
24585   Dali::Sampler *result = 0 ;
24586
24587   arg1 = (Dali::Sampler *)jarg1;
24588   if (!arg1) {
24589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24590     return 0;
24591   }
24592   {
24593     try {
24594       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24595     } catch (std::out_of_range& e) {
24596       {
24597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24598       };
24599     } catch (std::exception& e) {
24600       {
24601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (Dali::DaliException e) {
24604       {
24605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24606       };
24607     } catch (...) {
24608       {
24609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24610       };
24611     }
24612   }
24613
24614   jresult = (void *)result;
24615   return jresult;
24616 }
24617
24618
24619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24620   void * jresult ;
24621   Dali::BaseHandle arg1 ;
24622   Dali::BaseHandle *argp1 ;
24623   Dali::Sampler result;
24624
24625   argp1 = (Dali::BaseHandle *)jarg1;
24626   if (!argp1) {
24627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24628     return 0;
24629   }
24630   arg1 = *argp1;
24631   {
24632     try {
24633       result = Dali::Sampler::DownCast(arg1);
24634     } catch (std::out_of_range& e) {
24635       {
24636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24637       };
24638     } catch (std::exception& e) {
24639       {
24640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24641       };
24642     } catch (Dali::DaliException e) {
24643       {
24644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24645       };
24646     } catch (...) {
24647       {
24648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24649       };
24650     }
24651   }
24652
24653   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24654   return jresult;
24655 }
24656
24657
24658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24659   void * jresult ;
24660   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24661   Dali::Sampler *arg2 = 0 ;
24662   Dali::Sampler *result = 0 ;
24663
24664   arg1 = (Dali::Sampler *)jarg1;
24665   arg2 = (Dali::Sampler *)jarg2;
24666   if (!arg2) {
24667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24668     return 0;
24669   }
24670   {
24671     try {
24672       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24673     } catch (std::out_of_range& e) {
24674       {
24675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24676       };
24677     } catch (std::exception& e) {
24678       {
24679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24680       };
24681     } catch (Dali::DaliException e) {
24682       {
24683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24684       };
24685     } catch (...) {
24686       {
24687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24688       };
24689     }
24690   }
24691
24692   jresult = (void *)result;
24693   return jresult;
24694 }
24695
24696
24697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24698   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24699   Dali::FilterMode::Type arg2 ;
24700   Dali::FilterMode::Type arg3 ;
24701
24702   arg1 = (Dali::Sampler *)jarg1;
24703   arg2 = (Dali::FilterMode::Type)jarg2;
24704   arg3 = (Dali::FilterMode::Type)jarg3;
24705   {
24706     try {
24707       (arg1)->SetFilterMode(arg2,arg3);
24708     } catch (std::out_of_range& e) {
24709       {
24710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24711       };
24712     } catch (std::exception& e) {
24713       {
24714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24715       };
24716     } catch (Dali::DaliException e) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24719       };
24720     } catch (...) {
24721       {
24722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24723       };
24724     }
24725   }
24726
24727 }
24728
24729
24730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24731   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24732   Dali::WrapMode::Type arg2 ;
24733   Dali::WrapMode::Type arg3 ;
24734
24735   arg1 = (Dali::Sampler *)jarg1;
24736   arg2 = (Dali::WrapMode::Type)jarg2;
24737   arg3 = (Dali::WrapMode::Type)jarg3;
24738   {
24739     try {
24740       (arg1)->SetWrapMode(arg2,arg3);
24741     } catch (std::out_of_range& e) {
24742       {
24743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24744       };
24745     } catch (std::exception& e) {
24746       {
24747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24748       };
24749     } catch (Dali::DaliException e) {
24750       {
24751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24752       };
24753     } catch (...) {
24754       {
24755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24756       };
24757     }
24758   }
24759
24760 }
24761
24762
24763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24764   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24765   Dali::WrapMode::Type arg2 ;
24766   Dali::WrapMode::Type arg3 ;
24767   Dali::WrapMode::Type arg4 ;
24768
24769   arg1 = (Dali::Sampler *)jarg1;
24770   arg2 = (Dali::WrapMode::Type)jarg2;
24771   arg3 = (Dali::WrapMode::Type)jarg3;
24772   arg4 = (Dali::WrapMode::Type)jarg4;
24773   {
24774     try {
24775       (arg1)->SetWrapMode(arg2,arg3,arg4);
24776     } catch (std::out_of_range& e) {
24777       {
24778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24779       };
24780     } catch (std::exception& e) {
24781       {
24782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24783       };
24784     } catch (Dali::DaliException e) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24787       };
24788     } catch (...) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24791       };
24792     }
24793   }
24794
24795 }
24796
24797
24798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24799   void * jresult ;
24800   Dali::TextureSet result;
24801
24802   {
24803     try {
24804       result = Dali::TextureSet::New();
24805     } catch (std::out_of_range& e) {
24806       {
24807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24808       };
24809     } catch (std::exception& e) {
24810       {
24811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (Dali::DaliException e) {
24814       {
24815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24816       };
24817     } catch (...) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24820       };
24821     }
24822   }
24823
24824   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24825   return jresult;
24826 }
24827
24828
24829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24830   void * jresult ;
24831   Dali::TextureSet *result = 0 ;
24832
24833   {
24834     try {
24835       result = (Dali::TextureSet *)new Dali::TextureSet();
24836     } catch (std::out_of_range& e) {
24837       {
24838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (std::exception& e) {
24841       {
24842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (Dali::DaliException e) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24847       };
24848     } catch (...) {
24849       {
24850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24851       };
24852     }
24853   }
24854
24855   jresult = (void *)result;
24856   return jresult;
24857 }
24858
24859
24860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24861   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24862
24863   arg1 = (Dali::TextureSet *)jarg1;
24864   {
24865     try {
24866       delete arg1;
24867     } catch (std::out_of_range& e) {
24868       {
24869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24870       };
24871     } catch (std::exception& e) {
24872       {
24873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24874       };
24875     } catch (Dali::DaliException e) {
24876       {
24877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24878       };
24879     } catch (...) {
24880       {
24881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24882       };
24883     }
24884   }
24885
24886 }
24887
24888
24889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24890   void * jresult ;
24891   Dali::TextureSet *arg1 = 0 ;
24892   Dali::TextureSet *result = 0 ;
24893
24894   arg1 = (Dali::TextureSet *)jarg1;
24895   if (!arg1) {
24896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24897     return 0;
24898   }
24899   {
24900     try {
24901       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24902     } catch (std::out_of_range& e) {
24903       {
24904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24905       };
24906     } catch (std::exception& e) {
24907       {
24908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24909       };
24910     } catch (Dali::DaliException e) {
24911       {
24912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24913       };
24914     } catch (...) {
24915       {
24916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24917       };
24918     }
24919   }
24920
24921   jresult = (void *)result;
24922   return jresult;
24923 }
24924
24925
24926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24927   void * jresult ;
24928   Dali::BaseHandle arg1 ;
24929   Dali::BaseHandle *argp1 ;
24930   Dali::TextureSet result;
24931
24932   argp1 = (Dali::BaseHandle *)jarg1;
24933   if (!argp1) {
24934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24935     return 0;
24936   }
24937   arg1 = *argp1;
24938   {
24939     try {
24940       result = Dali::TextureSet::DownCast(arg1);
24941     } catch (std::out_of_range& e) {
24942       {
24943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24944       };
24945     } catch (std::exception& e) {
24946       {
24947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24948       };
24949     } catch (Dali::DaliException e) {
24950       {
24951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24952       };
24953     } catch (...) {
24954       {
24955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24956       };
24957     }
24958   }
24959
24960   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24961   return jresult;
24962 }
24963
24964
24965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24966   void * jresult ;
24967   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24968   Dali::TextureSet *arg2 = 0 ;
24969   Dali::TextureSet *result = 0 ;
24970
24971   arg1 = (Dali::TextureSet *)jarg1;
24972   arg2 = (Dali::TextureSet *)jarg2;
24973   if (!arg2) {
24974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24975     return 0;
24976   }
24977   {
24978     try {
24979       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24980     } catch (std::out_of_range& e) {
24981       {
24982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24983       };
24984     } catch (std::exception& e) {
24985       {
24986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24987       };
24988     } catch (Dali::DaliException e) {
24989       {
24990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24991       };
24992     } catch (...) {
24993       {
24994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24995       };
24996     }
24997   }
24998
24999   jresult = (void *)result;
25000   return jresult;
25001 }
25002
25003
25004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25005   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25006   size_t arg2 ;
25007   Dali::Texture arg3 ;
25008   Dali::Texture *argp3 ;
25009
25010   arg1 = (Dali::TextureSet *)jarg1;
25011   arg2 = (size_t)jarg2;
25012   argp3 = (Dali::Texture *)jarg3;
25013   if (!argp3) {
25014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25015     return ;
25016   }
25017   arg3 = *argp3;
25018   {
25019     try {
25020       (arg1)->SetTexture(arg2,arg3);
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25028       };
25029     } catch (Dali::DaliException e) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25032       };
25033     } catch (...) {
25034       {
25035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25036       };
25037     }
25038   }
25039
25040 }
25041
25042
25043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25044   void * jresult ;
25045   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25046   size_t arg2 ;
25047   Dali::Texture result;
25048
25049   arg1 = (Dali::TextureSet *)jarg1;
25050   arg2 = (size_t)jarg2;
25051   {
25052     try {
25053       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25054     } catch (std::out_of_range& e) {
25055       {
25056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25057       };
25058     } catch (std::exception& e) {
25059       {
25060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25061       };
25062     } catch (Dali::DaliException e) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25065       };
25066     } catch (...) {
25067       {
25068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25069       };
25070     }
25071   }
25072
25073   jresult = new Dali::Texture((const Dali::Texture &)result);
25074   return jresult;
25075 }
25076
25077
25078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25079   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25080   size_t arg2 ;
25081   Dali::Sampler arg3 ;
25082   Dali::Sampler *argp3 ;
25083
25084   arg1 = (Dali::TextureSet *)jarg1;
25085   arg2 = (size_t)jarg2;
25086   argp3 = (Dali::Sampler *)jarg3;
25087   if (!argp3) {
25088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25089     return ;
25090   }
25091   arg3 = *argp3;
25092   {
25093     try {
25094       (arg1)->SetSampler(arg2,arg3);
25095     } catch (std::out_of_range& e) {
25096       {
25097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25098       };
25099     } catch (std::exception& e) {
25100       {
25101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25102       };
25103     } catch (Dali::DaliException e) {
25104       {
25105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25106       };
25107     } catch (...) {
25108       {
25109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25110       };
25111     }
25112   }
25113
25114 }
25115
25116
25117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25118   void * jresult ;
25119   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25120   size_t arg2 ;
25121   Dali::Sampler result;
25122
25123   arg1 = (Dali::TextureSet *)jarg1;
25124   arg2 = (size_t)jarg2;
25125   {
25126     try {
25127       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25128     } catch (std::out_of_range& e) {
25129       {
25130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25131       };
25132     } catch (std::exception& e) {
25133       {
25134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25135       };
25136     } catch (Dali::DaliException e) {
25137       {
25138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25143       };
25144     }
25145   }
25146
25147   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25148   return jresult;
25149 }
25150
25151
25152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25153   unsigned long jresult ;
25154   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25155   size_t result;
25156
25157   arg1 = (Dali::TextureSet *)jarg1;
25158   {
25159     try {
25160       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25161     } catch (std::out_of_range& e) {
25162       {
25163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (std::exception& e) {
25166       {
25167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25168       };
25169     } catch (Dali::DaliException e) {
25170       {
25171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25172       };
25173     } catch (...) {
25174       {
25175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25176       };
25177     }
25178   }
25179
25180   jresult = (unsigned long)result;
25181   return jresult;
25182 }
25183
25184
25185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
25186   void * jresult ;
25187   Dali::Property::Map *arg1 = 0 ;
25188   Dali::VertexBuffer result;
25189
25190   arg1 = (Dali::Property::Map *)jarg1;
25191   if (!arg1) {
25192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25193     return 0;
25194   }
25195   {
25196     try {
25197       result = Dali::VertexBuffer::New(*arg1);
25198     } catch (std::out_of_range& e) {
25199       {
25200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25201       };
25202     } catch (std::exception& e) {
25203       {
25204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25205       };
25206     } catch (Dali::DaliException e) {
25207       {
25208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25209       };
25210     } catch (...) {
25211       {
25212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25213       };
25214     }
25215   }
25216
25217   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
25218   return jresult;
25219 }
25220
25221
25222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
25223   void * jresult ;
25224   Dali::VertexBuffer *result = 0 ;
25225
25226   {
25227     try {
25228       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = (void *)result;
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
25254   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25255
25256   arg1 = (Dali::VertexBuffer *)jarg1;
25257   {
25258     try {
25259       delete arg1;
25260     } catch (std::out_of_range& e) {
25261       {
25262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25263       };
25264     } catch (std::exception& e) {
25265       {
25266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25267       };
25268     } catch (Dali::DaliException e) {
25269       {
25270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25271       };
25272     } catch (...) {
25273       {
25274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25275       };
25276     }
25277   }
25278
25279 }
25280
25281
25282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
25283   void * jresult ;
25284   Dali::VertexBuffer *arg1 = 0 ;
25285   Dali::VertexBuffer *result = 0 ;
25286
25287   arg1 = (Dali::VertexBuffer *)jarg1;
25288   if (!arg1) {
25289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25290     return 0;
25291   }
25292   {
25293     try {
25294       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
25295     } catch (std::out_of_range& e) {
25296       {
25297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25298       };
25299     } catch (std::exception& e) {
25300       {
25301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25302       };
25303     } catch (Dali::DaliException e) {
25304       {
25305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25306       };
25307     } catch (...) {
25308       {
25309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25310       };
25311     }
25312   }
25313
25314   jresult = (void *)result;
25315   return jresult;
25316 }
25317
25318
25319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
25320   void * jresult ;
25321   Dali::BaseHandle arg1 ;
25322   Dali::BaseHandle *argp1 ;
25323   Dali::VertexBuffer result;
25324
25325   argp1 = (Dali::BaseHandle *)jarg1;
25326   if (!argp1) {
25327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25328     return 0;
25329   }
25330   arg1 = *argp1;
25331   {
25332     try {
25333       result = Dali::VertexBuffer::DownCast(arg1);
25334     } catch (std::out_of_range& e) {
25335       {
25336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25337       };
25338     } catch (std::exception& e) {
25339       {
25340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25341       };
25342     } catch (Dali::DaliException e) {
25343       {
25344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25345       };
25346     } catch (...) {
25347       {
25348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25349       };
25350     }
25351   }
25352
25353   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
25354   return jresult;
25355 }
25356
25357
25358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
25359   void * jresult ;
25360   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25361   Dali::VertexBuffer *arg2 = 0 ;
25362   Dali::VertexBuffer *result = 0 ;
25363
25364   arg1 = (Dali::VertexBuffer *)jarg1;
25365   arg2 = (Dali::VertexBuffer *)jarg2;
25366   if (!arg2) {
25367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25368     return 0;
25369   }
25370   {
25371     try {
25372       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
25373     } catch (std::out_of_range& e) {
25374       {
25375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25376       };
25377     } catch (std::exception& e) {
25378       {
25379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (Dali::DaliException e) {
25382       {
25383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25384       };
25385     } catch (...) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25388       };
25389     }
25390   }
25391
25392   jresult = (void *)result;
25393   return jresult;
25394 }
25395
25396
25397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25398   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25399   void *arg2 = (void *) 0 ;
25400   std::size_t arg3 ;
25401
25402   arg1 = (Dali::VertexBuffer *)jarg1;
25403   arg2 = jarg2;
25404   arg3 = (std::size_t)jarg3;
25405   {
25406     try {
25407       (arg1)->SetData((void const *)arg2,arg3);
25408     } catch (std::out_of_range& e) {
25409       {
25410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25411       };
25412     } catch (std::exception& e) {
25413       {
25414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25415       };
25416     } catch (Dali::DaliException e) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25419       };
25420     } catch (...) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25423       };
25424     }
25425   }
25426
25427 }
25428
25429
25430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
25431   unsigned long jresult ;
25432   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25433   std::size_t result;
25434
25435   arg1 = (Dali::VertexBuffer *)jarg1;
25436   {
25437     try {
25438       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
25439     } catch (std::out_of_range& e) {
25440       {
25441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25442       };
25443     } catch (std::exception& e) {
25444       {
25445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25446       };
25447     } catch (Dali::DaliException e) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25450       };
25451     } catch (...) {
25452       {
25453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25454       };
25455     }
25456   }
25457
25458   jresult = (unsigned long)result;
25459   return jresult;
25460 }
25461
25462
25463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25464   void * jresult ;
25465   Dali::Geometry result;
25466
25467   {
25468     try {
25469       result = Dali::Geometry::New();
25470     } catch (std::out_of_range& e) {
25471       {
25472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25473       };
25474     } catch (std::exception& e) {
25475       {
25476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25477       };
25478     } catch (Dali::DaliException e) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25481       };
25482     } catch (...) {
25483       {
25484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25485       };
25486     }
25487   }
25488
25489   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25495   void * jresult ;
25496   Dali::Geometry *result = 0 ;
25497
25498   {
25499     try {
25500       result = (Dali::Geometry *)new Dali::Geometry();
25501     } catch (std::out_of_range& e) {
25502       {
25503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (std::exception& e) {
25506       {
25507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25508       };
25509     } catch (Dali::DaliException e) {
25510       {
25511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25512       };
25513     } catch (...) {
25514       {
25515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25516       };
25517     }
25518   }
25519
25520   jresult = (void *)result;
25521   return jresult;
25522 }
25523
25524
25525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25526   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25527
25528   arg1 = (Dali::Geometry *)jarg1;
25529   {
25530     try {
25531       delete arg1;
25532     } catch (std::out_of_range& e) {
25533       {
25534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25535       };
25536     } catch (std::exception& e) {
25537       {
25538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25539       };
25540     } catch (Dali::DaliException e) {
25541       {
25542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25543       };
25544     } catch (...) {
25545       {
25546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25547       };
25548     }
25549   }
25550
25551 }
25552
25553
25554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25555   void * jresult ;
25556   Dali::Geometry *arg1 = 0 ;
25557   Dali::Geometry *result = 0 ;
25558
25559   arg1 = (Dali::Geometry *)jarg1;
25560   if (!arg1) {
25561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25562     return 0;
25563   }
25564   {
25565     try {
25566       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25567     } catch (std::out_of_range& e) {
25568       {
25569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25570       };
25571     } catch (std::exception& e) {
25572       {
25573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25574       };
25575     } catch (Dali::DaliException e) {
25576       {
25577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25578       };
25579     } catch (...) {
25580       {
25581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25582       };
25583     }
25584   }
25585
25586   jresult = (void *)result;
25587   return jresult;
25588 }
25589
25590
25591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25592   void * jresult ;
25593   Dali::BaseHandle arg1 ;
25594   Dali::BaseHandle *argp1 ;
25595   Dali::Geometry result;
25596
25597   argp1 = (Dali::BaseHandle *)jarg1;
25598   if (!argp1) {
25599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25600     return 0;
25601   }
25602   arg1 = *argp1;
25603   {
25604     try {
25605       result = Dali::Geometry::DownCast(arg1);
25606     } catch (std::out_of_range& e) {
25607       {
25608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25609       };
25610     } catch (std::exception& e) {
25611       {
25612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25613       };
25614     } catch (Dali::DaliException e) {
25615       {
25616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25617       };
25618     } catch (...) {
25619       {
25620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25621       };
25622     }
25623   }
25624
25625   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25626   return jresult;
25627 }
25628
25629
25630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25631   void * jresult ;
25632   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25633   Dali::Geometry *arg2 = 0 ;
25634   Dali::Geometry *result = 0 ;
25635
25636   arg1 = (Dali::Geometry *)jarg1;
25637   arg2 = (Dali::Geometry *)jarg2;
25638   if (!arg2) {
25639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25640     return 0;
25641   }
25642   {
25643     try {
25644       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25645     } catch (std::out_of_range& e) {
25646       {
25647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25648       };
25649     } catch (std::exception& e) {
25650       {
25651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25652       };
25653     } catch (Dali::DaliException e) {
25654       {
25655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25656       };
25657     } catch (...) {
25658       {
25659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25660       };
25661     }
25662   }
25663
25664   jresult = (void *)result;
25665   return jresult;
25666 }
25667
25668
25669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25670   unsigned long jresult ;
25671   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25672   Dali::VertexBuffer *arg2 = 0 ;
25673   std::size_t result;
25674
25675   arg1 = (Dali::Geometry *)jarg1;
25676   arg2 = (Dali::VertexBuffer *)jarg2;
25677   if (!arg2) {
25678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
25679     return 0;
25680   }
25681   {
25682     try {
25683       result = (arg1)->AddVertexBuffer(*arg2);
25684     } catch (std::out_of_range& e) {
25685       {
25686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25687       };
25688     } catch (std::exception& e) {
25689       {
25690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25691       };
25692     } catch (Dali::DaliException e) {
25693       {
25694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25695       };
25696     } catch (...) {
25697       {
25698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25699       };
25700     }
25701   }
25702
25703   jresult = (unsigned long)result;
25704   return jresult;
25705 }
25706
25707
25708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25709   unsigned long jresult ;
25710   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25711   std::size_t result;
25712
25713   arg1 = (Dali::Geometry *)jarg1;
25714   {
25715     try {
25716       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25717     } catch (std::out_of_range& e) {
25718       {
25719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (std::exception& e) {
25722       {
25723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (Dali::DaliException e) {
25726       {
25727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25728       };
25729     } catch (...) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25732       };
25733     }
25734   }
25735
25736   jresult = (unsigned long)result;
25737   return jresult;
25738 }
25739
25740
25741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25742   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25743   std::size_t arg2 ;
25744
25745   arg1 = (Dali::Geometry *)jarg1;
25746   arg2 = (std::size_t)jarg2;
25747   {
25748     try {
25749       (arg1)->RemoveVertexBuffer(arg2);
25750     } catch (std::out_of_range& e) {
25751       {
25752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25753       };
25754     } catch (std::exception& e) {
25755       {
25756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25757       };
25758     } catch (Dali::DaliException e) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25761       };
25762     } catch (...) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25765       };
25766     }
25767   }
25768
25769 }
25770
25771
25772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25774   unsigned short *arg2 = (unsigned short *) 0 ;
25775   size_t arg3 ;
25776
25777   arg1 = (Dali::Geometry *)jarg1;
25778   arg2 = jarg2;
25779   arg3 = (size_t)jarg3;
25780   {
25781     try {
25782       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25783     } catch (std::out_of_range& e) {
25784       {
25785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (std::exception& e) {
25788       {
25789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25790       };
25791     } catch (Dali::DaliException e) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25794       };
25795     } catch (...) {
25796       {
25797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25798       };
25799     }
25800   }
25801
25802
25803
25804 }
25805
25806
25807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25808   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25809   Dali::Geometry::Type arg2 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   arg2 = (Dali::Geometry::Type)jarg2;
25813   {
25814     try {
25815       (arg1)->SetType(arg2);
25816     } catch (std::out_of_range& e) {
25817       {
25818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25819       };
25820     } catch (std::exception& e) {
25821       {
25822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25823       };
25824     } catch (Dali::DaliException e) {
25825       {
25826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25827       };
25828     } catch (...) {
25829       {
25830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25831       };
25832     }
25833   }
25834
25835 }
25836
25837
25838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25839   int jresult ;
25840   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25841   Dali::Geometry::Type result;
25842
25843   arg1 = (Dali::Geometry *)jarg1;
25844   {
25845     try {
25846       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25847     } catch (std::out_of_range& e) {
25848       {
25849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25850       };
25851     } catch (std::exception& e) {
25852       {
25853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25854       };
25855     } catch (Dali::DaliException e) {
25856       {
25857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25858       };
25859     } catch (...) {
25860       {
25861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25862       };
25863     }
25864   }
25865
25866   jresult = (int)result;
25867   return jresult;
25868 }
25869
25870
25871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25872   void * jresult ;
25873   Dali::Shader::Hint *result = 0 ;
25874
25875   {
25876     try {
25877       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25878     } catch (std::out_of_range& e) {
25879       {
25880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (std::exception& e) {
25883       {
25884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25885       };
25886     } catch (Dali::DaliException e) {
25887       {
25888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25889       };
25890     } catch (...) {
25891       {
25892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25893       };
25894     }
25895   }
25896
25897   jresult = (void *)result;
25898   return jresult;
25899 }
25900
25901
25902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25903   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25904
25905   arg1 = (Dali::Shader::Hint *)jarg1;
25906   {
25907     try {
25908       delete arg1;
25909     } catch (std::out_of_range& e) {
25910       {
25911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25912       };
25913     } catch (std::exception& e) {
25914       {
25915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25916       };
25917     } catch (Dali::DaliException e) {
25918       {
25919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25920       };
25921     } catch (...) {
25922       {
25923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25924       };
25925     }
25926   }
25927
25928 }
25929
25930
25931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25932   int jresult ;
25933   int result;
25934
25935   result = (int)Dali::Shader::Property::PROGRAM;
25936   jresult = (int)result;
25937   return jresult;
25938 }
25939
25940
25941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25942   void * jresult ;
25943   Dali::Shader::Property *result = 0 ;
25944
25945   {
25946     try {
25947       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25948     } catch (std::out_of_range& e) {
25949       {
25950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25951       };
25952     } catch (std::exception& e) {
25953       {
25954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25955       };
25956     } catch (Dali::DaliException e) {
25957       {
25958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25959       };
25960     } catch (...) {
25961       {
25962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25963       };
25964     }
25965   }
25966
25967   jresult = (void *)result;
25968   return jresult;
25969 }
25970
25971
25972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25973   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25974
25975   arg1 = (Dali::Shader::Property *)jarg1;
25976   {
25977     try {
25978       delete arg1;
25979     } catch (std::out_of_range& e) {
25980       {
25981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25982       };
25983     } catch (std::exception& e) {
25984       {
25985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25986       };
25987     } catch (Dali::DaliException e) {
25988       {
25989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25990       };
25991     } catch (...) {
25992       {
25993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25994       };
25995     }
25996   }
25997
25998 }
25999
26000
26001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26002   void * jresult ;
26003   std::string *arg1 = 0 ;
26004   std::string *arg2 = 0 ;
26005   Dali::Shader::Hint::Value arg3 ;
26006   Dali::Shader result;
26007
26008   if (!jarg1) {
26009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26010     return 0;
26011   }
26012   std::string arg1_str(jarg1);
26013   arg1 = &arg1_str;
26014   if (!jarg2) {
26015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26016     return 0;
26017   }
26018   std::string arg2_str(jarg2);
26019   arg2 = &arg2_str;
26020   arg3 = (Dali::Shader::Hint::Value)jarg3;
26021   {
26022     try {
26023       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26024     } catch (std::out_of_range& e) {
26025       {
26026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26027       };
26028     } catch (std::exception& e) {
26029       {
26030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26031       };
26032     } catch (Dali::DaliException e) {
26033       {
26034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26035       };
26036     } catch (...) {
26037       {
26038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26039       };
26040     }
26041   }
26042
26043   jresult = new Dali::Shader((const Dali::Shader &)result);
26044
26045   //argout typemap for const std::string&
26046
26047
26048   //argout typemap for const std::string&
26049
26050   return jresult;
26051 }
26052
26053
26054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26055   void * jresult ;
26056   std::string *arg1 = 0 ;
26057   std::string *arg2 = 0 ;
26058   Dali::Shader result;
26059
26060   if (!jarg1) {
26061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26062     return 0;
26063   }
26064   std::string arg1_str(jarg1);
26065   arg1 = &arg1_str;
26066   if (!jarg2) {
26067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26068     return 0;
26069   }
26070   std::string arg2_str(jarg2);
26071   arg2 = &arg2_str;
26072   {
26073     try {
26074       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26075     } catch (std::out_of_range& e) {
26076       {
26077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26078       };
26079     } catch (std::exception& e) {
26080       {
26081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26082       };
26083     } catch (Dali::DaliException e) {
26084       {
26085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26086       };
26087     } catch (...) {
26088       {
26089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26090       };
26091     }
26092   }
26093
26094   jresult = new Dali::Shader((const Dali::Shader &)result);
26095
26096   //argout typemap for const std::string&
26097
26098
26099   //argout typemap for const std::string&
26100
26101   return jresult;
26102 }
26103
26104
26105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26106   void * jresult ;
26107   Dali::Shader *result = 0 ;
26108
26109   {
26110     try {
26111       result = (Dali::Shader *)new Dali::Shader();
26112     } catch (std::out_of_range& e) {
26113       {
26114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26115       };
26116     } catch (std::exception& e) {
26117       {
26118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26119       };
26120     } catch (Dali::DaliException e) {
26121       {
26122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26123       };
26124     } catch (...) {
26125       {
26126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26127       };
26128     }
26129   }
26130
26131   jresult = (void *)result;
26132   return jresult;
26133 }
26134
26135
26136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26137   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26138
26139   arg1 = (Dali::Shader *)jarg1;
26140   {
26141     try {
26142       delete arg1;
26143     } catch (std::out_of_range& e) {
26144       {
26145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26146       };
26147     } catch (std::exception& e) {
26148       {
26149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26150       };
26151     } catch (Dali::DaliException e) {
26152       {
26153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26154       };
26155     } catch (...) {
26156       {
26157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26158       };
26159     }
26160   }
26161
26162 }
26163
26164
26165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26166   void * jresult ;
26167   Dali::Shader *arg1 = 0 ;
26168   Dali::Shader *result = 0 ;
26169
26170   arg1 = (Dali::Shader *)jarg1;
26171   if (!arg1) {
26172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26173     return 0;
26174   }
26175   {
26176     try {
26177       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26178     } catch (std::out_of_range& e) {
26179       {
26180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26181       };
26182     } catch (std::exception& e) {
26183       {
26184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26185       };
26186     } catch (Dali::DaliException e) {
26187       {
26188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26189       };
26190     } catch (...) {
26191       {
26192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26193       };
26194     }
26195   }
26196
26197   jresult = (void *)result;
26198   return jresult;
26199 }
26200
26201
26202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26203   void * jresult ;
26204   Dali::BaseHandle arg1 ;
26205   Dali::BaseHandle *argp1 ;
26206   Dali::Shader result;
26207
26208   argp1 = (Dali::BaseHandle *)jarg1;
26209   if (!argp1) {
26210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26211     return 0;
26212   }
26213   arg1 = *argp1;
26214   {
26215     try {
26216       result = Dali::Shader::DownCast(arg1);
26217     } catch (std::out_of_range& e) {
26218       {
26219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26220       };
26221     } catch (std::exception& e) {
26222       {
26223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26224       };
26225     } catch (Dali::DaliException e) {
26226       {
26227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26228       };
26229     } catch (...) {
26230       {
26231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26232       };
26233     }
26234   }
26235
26236   jresult = new Dali::Shader((const Dali::Shader &)result);
26237   return jresult;
26238 }
26239
26240
26241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26242   void * jresult ;
26243   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26244   Dali::Shader *arg2 = 0 ;
26245   Dali::Shader *result = 0 ;
26246
26247   arg1 = (Dali::Shader *)jarg1;
26248   arg2 = (Dali::Shader *)jarg2;
26249   if (!arg2) {
26250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26251     return 0;
26252   }
26253   {
26254     try {
26255       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26256     } catch (std::out_of_range& e) {
26257       {
26258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26259       };
26260     } catch (std::exception& e) {
26261       {
26262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26263       };
26264     } catch (Dali::DaliException e) {
26265       {
26266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26267       };
26268     } catch (...) {
26269       {
26270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26271       };
26272     }
26273   }
26274
26275   jresult = (void *)result;
26276   return jresult;
26277 }
26278
26279
26280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26281   int jresult ;
26282   int result;
26283
26284   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26285   jresult = (int)result;
26286   return jresult;
26287 }
26288
26289
26290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26291   int jresult ;
26292   int result;
26293
26294   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26295   jresult = (int)result;
26296   return jresult;
26297 }
26298
26299
26300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26301   int jresult ;
26302   int result;
26303
26304   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26305   jresult = (int)result;
26306   return jresult;
26307 }
26308
26309
26310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26311   int jresult ;
26312   int result;
26313
26314   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26315   jresult = (int)result;
26316   return jresult;
26317 }
26318
26319
26320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26321   int jresult ;
26322   int result;
26323
26324   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26325   jresult = (int)result;
26326   return jresult;
26327 }
26328
26329
26330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26331   int jresult ;
26332   int result;
26333
26334   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26335   jresult = (int)result;
26336   return jresult;
26337 }
26338
26339
26340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26341   int jresult ;
26342   int result;
26343
26344   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26345   jresult = (int)result;
26346   return jresult;
26347 }
26348
26349
26350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26351   int jresult ;
26352   int result;
26353
26354   result = (int)Dali::Renderer::Property::BLEND_MODE;
26355   jresult = (int)result;
26356   return jresult;
26357 }
26358
26359
26360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26361   int jresult ;
26362   int result;
26363
26364   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26365   jresult = (int)result;
26366   return jresult;
26367 }
26368
26369
26370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26371   int jresult ;
26372   int result;
26373
26374   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26375   jresult = (int)result;
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26381   int jresult ;
26382   int result;
26383
26384   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26385   jresult = (int)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26391   int jresult ;
26392   int result;
26393
26394   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26395   jresult = (int)result;
26396   return jresult;
26397 }
26398
26399
26400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26401   int jresult ;
26402   int result;
26403
26404   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26405   jresult = (int)result;
26406   return jresult;
26407 }
26408
26409
26410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26411   int jresult ;
26412   int result;
26413
26414   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26415   jresult = (int)result;
26416   return jresult;
26417 }
26418
26419
26420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26421   int jresult ;
26422   int result;
26423
26424   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26425   jresult = (int)result;
26426   return jresult;
26427 }
26428
26429
26430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26431   int jresult ;
26432   int result;
26433
26434   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26435   jresult = (int)result;
26436   return jresult;
26437 }
26438
26439
26440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26441   int jresult ;
26442   int result;
26443
26444   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26445   jresult = (int)result;
26446   return jresult;
26447 }
26448
26449
26450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26451   int jresult ;
26452   int result;
26453
26454   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26455   jresult = (int)result;
26456   return jresult;
26457 }
26458
26459
26460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26461   int jresult ;
26462   int result;
26463
26464   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26465   jresult = (int)result;
26466   return jresult;
26467 }
26468
26469
26470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26471   int jresult ;
26472   int result;
26473
26474   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26475   jresult = (int)result;
26476   return jresult;
26477 }
26478
26479
26480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26481   int jresult ;
26482   int result;
26483
26484   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26485   jresult = (int)result;
26486   return jresult;
26487 }
26488
26489
26490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26491   int jresult ;
26492   int result;
26493
26494   result = (int)Dali::Renderer::Property::RENDER_MODE;
26495   jresult = (int)result;
26496   return jresult;
26497 }
26498
26499
26500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26501   int jresult ;
26502   int result;
26503
26504   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26505   jresult = (int)result;
26506   return jresult;
26507 }
26508
26509
26510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26511   int jresult ;
26512   int result;
26513
26514   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26515   jresult = (int)result;
26516   return jresult;
26517 }
26518
26519
26520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26521   int jresult ;
26522   int result;
26523
26524   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26525   jresult = (int)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26531   int jresult ;
26532   int result;
26533
26534   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26535   jresult = (int)result;
26536   return jresult;
26537 }
26538
26539
26540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26541   int jresult ;
26542   int result;
26543
26544   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26545   jresult = (int)result;
26546   return jresult;
26547 }
26548
26549
26550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26551   int jresult ;
26552   int result;
26553
26554   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26555   jresult = (int)result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26561   int jresult ;
26562   int result;
26563
26564   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26565   jresult = (int)result;
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26571   void * jresult ;
26572   Dali::Renderer::Property *result = 0 ;
26573
26574   {
26575     try {
26576       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26577     } catch (std::out_of_range& e) {
26578       {
26579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (std::exception& e) {
26582       {
26583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26584       };
26585     } catch (Dali::DaliException e) {
26586       {
26587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26588       };
26589     } catch (...) {
26590       {
26591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26592       };
26593     }
26594   }
26595
26596   jresult = (void *)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26602   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26603
26604   arg1 = (Dali::Renderer::Property *)jarg1;
26605   {
26606     try {
26607       delete arg1;
26608     } catch (std::out_of_range& e) {
26609       {
26610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26611       };
26612     } catch (std::exception& e) {
26613       {
26614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26615       };
26616     } catch (Dali::DaliException e) {
26617       {
26618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26619       };
26620     } catch (...) {
26621       {
26622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26623       };
26624     }
26625   }
26626
26627 }
26628
26629
26630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26631   void * jresult ;
26632   Dali::Geometry *arg1 = 0 ;
26633   Dali::Shader *arg2 = 0 ;
26634   Dali::Renderer result;
26635
26636   arg1 = (Dali::Geometry *)jarg1;
26637   if (!arg1) {
26638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26639     return 0;
26640   }
26641   arg2 = (Dali::Shader *)jarg2;
26642   if (!arg2) {
26643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26644     return 0;
26645   }
26646   {
26647     try {
26648       result = Dali::Renderer::New(*arg1,*arg2);
26649     } catch (std::out_of_range& e) {
26650       {
26651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26652       };
26653     } catch (std::exception& e) {
26654       {
26655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26656       };
26657     } catch (Dali::DaliException e) {
26658       {
26659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26660       };
26661     } catch (...) {
26662       {
26663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26664       };
26665     }
26666   }
26667
26668   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26669   return jresult;
26670 }
26671
26672
26673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26674   void * jresult ;
26675   Dali::Renderer *result = 0 ;
26676
26677   {
26678     try {
26679       result = (Dali::Renderer *)new Dali::Renderer();
26680     } catch (std::out_of_range& e) {
26681       {
26682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26683       };
26684     } catch (std::exception& e) {
26685       {
26686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26687       };
26688     } catch (Dali::DaliException e) {
26689       {
26690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26691       };
26692     } catch (...) {
26693       {
26694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26695       };
26696     }
26697   }
26698
26699   jresult = (void *)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26705   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26706
26707   arg1 = (Dali::Renderer *)jarg1;
26708   {
26709     try {
26710       delete arg1;
26711     } catch (std::out_of_range& e) {
26712       {
26713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26714       };
26715     } catch (std::exception& e) {
26716       {
26717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26718       };
26719     } catch (Dali::DaliException e) {
26720       {
26721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26722       };
26723     } catch (...) {
26724       {
26725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26726       };
26727     }
26728   }
26729
26730 }
26731
26732
26733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26734   void * jresult ;
26735   Dali::Renderer *arg1 = 0 ;
26736   Dali::Renderer *result = 0 ;
26737
26738   arg1 = (Dali::Renderer *)jarg1;
26739   if (!arg1) {
26740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26741     return 0;
26742   }
26743   {
26744     try {
26745       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26746     } catch (std::out_of_range& e) {
26747       {
26748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26749       };
26750     } catch (std::exception& e) {
26751       {
26752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26753       };
26754     } catch (Dali::DaliException e) {
26755       {
26756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26757       };
26758     } catch (...) {
26759       {
26760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26761       };
26762     }
26763   }
26764
26765   jresult = (void *)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26771   void * jresult ;
26772   Dali::BaseHandle arg1 ;
26773   Dali::BaseHandle *argp1 ;
26774   Dali::Renderer result;
26775
26776   argp1 = (Dali::BaseHandle *)jarg1;
26777   if (!argp1) {
26778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26779     return 0;
26780   }
26781   arg1 = *argp1;
26782   {
26783     try {
26784       result = Dali::Renderer::DownCast(arg1);
26785     } catch (std::out_of_range& e) {
26786       {
26787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26788       };
26789     } catch (std::exception& e) {
26790       {
26791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26792       };
26793     } catch (Dali::DaliException e) {
26794       {
26795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26796       };
26797     } catch (...) {
26798       {
26799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26800       };
26801     }
26802   }
26803
26804   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26805   return jresult;
26806 }
26807
26808
26809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26810   void * jresult ;
26811   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26812   Dali::Renderer *arg2 = 0 ;
26813   Dali::Renderer *result = 0 ;
26814
26815   arg1 = (Dali::Renderer *)jarg1;
26816   arg2 = (Dali::Renderer *)jarg2;
26817   if (!arg2) {
26818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26819     return 0;
26820   }
26821   {
26822     try {
26823       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26824     } catch (std::out_of_range& e) {
26825       {
26826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26827       };
26828     } catch (std::exception& e) {
26829       {
26830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26831       };
26832     } catch (Dali::DaliException e) {
26833       {
26834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26835       };
26836     } catch (...) {
26837       {
26838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26839       };
26840     }
26841   }
26842
26843   jresult = (void *)result;
26844   return jresult;
26845 }
26846
26847
26848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26849   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26850   Dali::Geometry *arg2 = 0 ;
26851
26852   arg1 = (Dali::Renderer *)jarg1;
26853   arg2 = (Dali::Geometry *)jarg2;
26854   if (!arg2) {
26855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26856     return ;
26857   }
26858   {
26859     try {
26860       (arg1)->SetGeometry(*arg2);
26861     } catch (std::out_of_range& e) {
26862       {
26863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26864       };
26865     } catch (std::exception& e) {
26866       {
26867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26868       };
26869     } catch (Dali::DaliException e) {
26870       {
26871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26872       };
26873     } catch (...) {
26874       {
26875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26876       };
26877     }
26878   }
26879
26880 }
26881
26882
26883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26884   void * jresult ;
26885   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26886   Dali::Geometry result;
26887
26888   arg1 = (Dali::Renderer *)jarg1;
26889   {
26890     try {
26891       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26892     } catch (std::out_of_range& e) {
26893       {
26894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26895       };
26896     } catch (std::exception& e) {
26897       {
26898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26899       };
26900     } catch (Dali::DaliException e) {
26901       {
26902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26903       };
26904     } catch (...) {
26905       {
26906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26907       };
26908     }
26909   }
26910
26911   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26912   return jresult;
26913 }
26914
26915
26916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26917   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26918   int arg2 ;
26919   int arg3 ;
26920
26921   arg1 = (Dali::Renderer *)jarg1;
26922   arg2 = (int)jarg2;
26923   arg3 = (int)jarg3;
26924   {
26925     try {
26926       (arg1)->SetIndexRange(arg2,arg3);
26927     } catch (std::out_of_range& e) {
26928       {
26929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26930       };
26931     } catch (std::exception& e) {
26932       {
26933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26934       };
26935     } catch (Dali::DaliException e) {
26936       {
26937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26938       };
26939     } catch (...) {
26940       {
26941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26942       };
26943     }
26944   }
26945
26946 }
26947
26948
26949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26950   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26951   Dali::TextureSet *arg2 = 0 ;
26952
26953   arg1 = (Dali::Renderer *)jarg1;
26954   arg2 = (Dali::TextureSet *)jarg2;
26955   if (!arg2) {
26956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26957     return ;
26958   }
26959   {
26960     try {
26961       (arg1)->SetTextures(*arg2);
26962     } catch (std::out_of_range& e) {
26963       {
26964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (std::exception& e) {
26967       {
26968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26969       };
26970     } catch (Dali::DaliException e) {
26971       {
26972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26973       };
26974     } catch (...) {
26975       {
26976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26977       };
26978     }
26979   }
26980
26981 }
26982
26983
26984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26985   void * jresult ;
26986   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26987   Dali::TextureSet result;
26988
26989   arg1 = (Dali::Renderer *)jarg1;
26990   {
26991     try {
26992       result = ((Dali::Renderer const *)arg1)->GetTextures();
26993     } catch (std::out_of_range& e) {
26994       {
26995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26996       };
26997     } catch (std::exception& e) {
26998       {
26999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27000       };
27001     } catch (Dali::DaliException e) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27004       };
27005     } catch (...) {
27006       {
27007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27008       };
27009     }
27010   }
27011
27012   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27013   return jresult;
27014 }
27015
27016
27017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27018   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27019   Dali::Shader *arg2 = 0 ;
27020
27021   arg1 = (Dali::Renderer *)jarg1;
27022   arg2 = (Dali::Shader *)jarg2;
27023   if (!arg2) {
27024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27025     return ;
27026   }
27027   {
27028     try {
27029       (arg1)->SetShader(*arg2);
27030     } catch (std::out_of_range& e) {
27031       {
27032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27033       };
27034     } catch (std::exception& e) {
27035       {
27036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27037       };
27038     } catch (Dali::DaliException e) {
27039       {
27040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27041       };
27042     } catch (...) {
27043       {
27044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27045       };
27046     }
27047   }
27048
27049 }
27050
27051
27052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27053   void * jresult ;
27054   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27055   Dali::Shader result;
27056
27057   arg1 = (Dali::Renderer *)jarg1;
27058   {
27059     try {
27060       result = ((Dali::Renderer const *)arg1)->GetShader();
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27076       };
27077     }
27078   }
27079
27080   jresult = new Dali::Shader((const Dali::Shader &)result);
27081   return jresult;
27082 }
27083
27084
27085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27086   void * jresult ;
27087   Dali::FrameBuffer::Attachment *result = 0 ;
27088
27089   {
27090     try {
27091       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = (void *)result;
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27117   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27118
27119   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27120   {
27121     try {
27122       delete arg1;
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (Dali::DaliException e) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27138       };
27139     }
27140   }
27141
27142 }
27143
27144
27145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27146   void * jresult ;
27147   unsigned int arg1 ;
27148   unsigned int arg2 ;
27149   unsigned int arg3 ;
27150   Dali::FrameBuffer result;
27151
27152   arg1 = (unsigned int)jarg1;
27153   arg2 = (unsigned int)jarg2;
27154   arg3 = (unsigned int)jarg3;
27155   {
27156     try {
27157       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27158     } catch (std::out_of_range& e) {
27159       {
27160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27161       };
27162     } catch (std::exception& e) {
27163       {
27164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27165       };
27166     } catch (Dali::DaliException e) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27169       };
27170     } catch (...) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27173       };
27174     }
27175   }
27176
27177   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27178   return jresult;
27179 }
27180
27181
27182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27183   void * jresult ;
27184   Dali::FrameBuffer *result = 0 ;
27185
27186   {
27187     try {
27188       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207
27208   jresult = (void *)result;
27209   return jresult;
27210 }
27211
27212
27213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27214   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27215
27216   arg1 = (Dali::FrameBuffer *)jarg1;
27217   {
27218     try {
27219       delete arg1;
27220     } catch (std::out_of_range& e) {
27221       {
27222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (std::exception& e) {
27225       {
27226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27227       };
27228     } catch (Dali::DaliException e) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27231       };
27232     } catch (...) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27235       };
27236     }
27237   }
27238
27239 }
27240
27241
27242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27243   void * jresult ;
27244   Dali::FrameBuffer *arg1 = 0 ;
27245   Dali::FrameBuffer *result = 0 ;
27246
27247   arg1 = (Dali::FrameBuffer *)jarg1;
27248   if (!arg1) {
27249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27250     return 0;
27251   }
27252   {
27253     try {
27254       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27255     } catch (std::out_of_range& e) {
27256       {
27257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (std::exception& e) {
27260       {
27261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27262       };
27263     } catch (Dali::DaliException e) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27266       };
27267     } catch (...) {
27268       {
27269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27270       };
27271     }
27272   }
27273
27274   jresult = (void *)result;
27275   return jresult;
27276 }
27277
27278
27279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27280   void * jresult ;
27281   Dali::BaseHandle arg1 ;
27282   Dali::BaseHandle *argp1 ;
27283   Dali::FrameBuffer result;
27284
27285   argp1 = (Dali::BaseHandle *)jarg1;
27286   if (!argp1) {
27287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27288     return 0;
27289   }
27290   arg1 = *argp1;
27291   {
27292     try {
27293       result = Dali::FrameBuffer::DownCast(arg1);
27294     } catch (std::out_of_range& e) {
27295       {
27296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27297       };
27298     } catch (std::exception& e) {
27299       {
27300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27301       };
27302     } catch (Dali::DaliException e) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27305       };
27306     } catch (...) {
27307       {
27308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27309       };
27310     }
27311   }
27312
27313   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27314   return jresult;
27315 }
27316
27317
27318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27319   void * jresult ;
27320   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27321   Dali::FrameBuffer *arg2 = 0 ;
27322   Dali::FrameBuffer *result = 0 ;
27323
27324   arg1 = (Dali::FrameBuffer *)jarg1;
27325   arg2 = (Dali::FrameBuffer *)jarg2;
27326   if (!arg2) {
27327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27328     return 0;
27329   }
27330   {
27331     try {
27332       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27333     } catch (std::out_of_range& e) {
27334       {
27335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27336       };
27337     } catch (std::exception& e) {
27338       {
27339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27340       };
27341     } catch (Dali::DaliException e) {
27342       {
27343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27344       };
27345     } catch (...) {
27346       {
27347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27348       };
27349     }
27350   }
27351
27352   jresult = (void *)result;
27353   return jresult;
27354 }
27355
27356
27357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27358   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27359   Dali::Texture *arg2 = 0 ;
27360
27361   arg1 = (Dali::FrameBuffer *)jarg1;
27362   arg2 = (Dali::Texture *)jarg2;
27363   if (!arg2) {
27364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27365     return ;
27366   }
27367   {
27368     try {
27369       (arg1)->AttachColorTexture(*arg2);
27370     } catch (std::out_of_range& e) {
27371       {
27372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27373       };
27374     } catch (std::exception& e) {
27375       {
27376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27377       };
27378     } catch (Dali::DaliException e) {
27379       {
27380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27381       };
27382     } catch (...) {
27383       {
27384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27385       };
27386     }
27387   }
27388
27389 }
27390
27391
27392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27393   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27394   Dali::Texture *arg2 = 0 ;
27395   unsigned int arg3 ;
27396   unsigned int arg4 ;
27397
27398   arg1 = (Dali::FrameBuffer *)jarg1;
27399   arg2 = (Dali::Texture *)jarg2;
27400   if (!arg2) {
27401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27402     return ;
27403   }
27404   arg3 = (unsigned int)jarg3;
27405   arg4 = (unsigned int)jarg4;
27406   {
27407     try {
27408       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27409     } catch (std::out_of_range& e) {
27410       {
27411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27412       };
27413     } catch (std::exception& e) {
27414       {
27415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27416       };
27417     } catch (Dali::DaliException e) {
27418       {
27419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27420       };
27421     } catch (...) {
27422       {
27423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27424       };
27425     }
27426   }
27427
27428 }
27429
27430
27431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27432   void * jresult ;
27433   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27434   Dali::Texture result;
27435
27436   arg1 = (Dali::FrameBuffer *)jarg1;
27437   {
27438     try {
27439       result = (arg1)->GetColorTexture();
27440     } catch (std::out_of_range& e) {
27441       {
27442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27443       };
27444     } catch (std::exception& e) {
27445       {
27446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27447       };
27448     } catch (Dali::DaliException e) {
27449       {
27450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27451       };
27452     } catch (...) {
27453       {
27454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27455       };
27456     }
27457   }
27458
27459   jresult = new Dali::Texture((const Dali::Texture &)result);
27460   return jresult;
27461 }
27462
27463
27464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27465   void * jresult ;
27466   Dali::RenderTaskList *result = 0 ;
27467
27468   {
27469     try {
27470       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27471     } catch (std::out_of_range& e) {
27472       {
27473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27474       };
27475     } catch (std::exception& e) {
27476       {
27477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27478       };
27479     } catch (Dali::DaliException e) {
27480       {
27481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27482       };
27483     } catch (...) {
27484       {
27485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27486       };
27487     }
27488   }
27489
27490   jresult = (void *)result;
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27496   void * jresult ;
27497   Dali::BaseHandle arg1 ;
27498   Dali::BaseHandle *argp1 ;
27499   Dali::RenderTaskList result;
27500
27501   argp1 = (Dali::BaseHandle *)jarg1;
27502   if (!argp1) {
27503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27504     return 0;
27505   }
27506   arg1 = *argp1;
27507   {
27508     try {
27509       result = Dali::RenderTaskList::DownCast(arg1);
27510     } catch (std::out_of_range& e) {
27511       {
27512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27513       };
27514     } catch (std::exception& e) {
27515       {
27516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27517       };
27518     } catch (Dali::DaliException e) {
27519       {
27520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27521       };
27522     } catch (...) {
27523       {
27524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27525       };
27526     }
27527   }
27528
27529   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27530   return jresult;
27531 }
27532
27533
27534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27535   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27536
27537   arg1 = (Dali::RenderTaskList *)jarg1;
27538   {
27539     try {
27540       delete arg1;
27541     } catch (std::out_of_range& e) {
27542       {
27543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27544       };
27545     } catch (std::exception& e) {
27546       {
27547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27548       };
27549     } catch (Dali::DaliException e) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27552       };
27553     } catch (...) {
27554       {
27555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27556       };
27557     }
27558   }
27559
27560 }
27561
27562
27563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27564   void * jresult ;
27565   Dali::RenderTaskList *arg1 = 0 ;
27566   Dali::RenderTaskList *result = 0 ;
27567
27568   arg1 = (Dali::RenderTaskList *)jarg1;
27569   if (!arg1) {
27570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27571     return 0;
27572   }
27573   {
27574     try {
27575       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27576     } catch (std::out_of_range& e) {
27577       {
27578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27579       };
27580     } catch (std::exception& e) {
27581       {
27582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27583       };
27584     } catch (Dali::DaliException e) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27587       };
27588     } catch (...) {
27589       {
27590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27591       };
27592     }
27593   }
27594
27595   jresult = (void *)result;
27596   return jresult;
27597 }
27598
27599
27600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27601   void * jresult ;
27602   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27603   Dali::RenderTaskList *arg2 = 0 ;
27604   Dali::RenderTaskList *result = 0 ;
27605
27606   arg1 = (Dali::RenderTaskList *)jarg1;
27607   arg2 = (Dali::RenderTaskList *)jarg2;
27608   if (!arg2) {
27609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27610     return 0;
27611   }
27612   {
27613     try {
27614       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27615     } catch (std::out_of_range& e) {
27616       {
27617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (std::exception& e) {
27620       {
27621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27622       };
27623     } catch (Dali::DaliException e) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27626       };
27627     } catch (...) {
27628       {
27629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27630       };
27631     }
27632   }
27633
27634   jresult = (void *)result;
27635   return jresult;
27636 }
27637
27638
27639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27640   void * jresult ;
27641   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27642   Dali::RenderTask result;
27643
27644   arg1 = (Dali::RenderTaskList *)jarg1;
27645   {
27646     try {
27647       result = (arg1)->CreateTask();
27648     } catch (std::out_of_range& e) {
27649       {
27650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27651       };
27652     } catch (std::exception& e) {
27653       {
27654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27655       };
27656     } catch (Dali::DaliException e) {
27657       {
27658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27659       };
27660     } catch (...) {
27661       {
27662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27663       };
27664     }
27665   }
27666
27667   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27668   return jresult;
27669 }
27670
27671
27672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27673   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27674   Dali::RenderTask arg2 ;
27675   Dali::RenderTask *argp2 ;
27676
27677   arg1 = (Dali::RenderTaskList *)jarg1;
27678   argp2 = (Dali::RenderTask *)jarg2;
27679   if (!argp2) {
27680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27681     return ;
27682   }
27683   arg2 = *argp2;
27684   {
27685     try {
27686       (arg1)->RemoveTask(arg2);
27687     } catch (std::out_of_range& e) {
27688       {
27689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27690       };
27691     } catch (std::exception& e) {
27692       {
27693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27694       };
27695     } catch (Dali::DaliException e) {
27696       {
27697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27698       };
27699     } catch (...) {
27700       {
27701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27702       };
27703     }
27704   }
27705
27706 }
27707
27708
27709 //// ===============================================end part 1 =================
27710
27711 //// ========================= part 2 ===============================
27712
27713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27714   unsigned int jresult ;
27715   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27716   unsigned int result;
27717
27718   arg1 = (Dali::RenderTaskList *)jarg1;
27719   {
27720     try {
27721       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27722     } catch (std::out_of_range& e) {
27723       {
27724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27725       };
27726     } catch (std::exception& e) {
27727       {
27728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27729       };
27730     } catch (Dali::DaliException e) {
27731       {
27732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27733       };
27734     } catch (...) {
27735       {
27736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27737       };
27738     }
27739   }
27740
27741   jresult = result;
27742   return jresult;
27743 }
27744
27745
27746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27747   void * jresult ;
27748   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27749   unsigned int arg2 ;
27750   Dali::RenderTask result;
27751
27752   arg1 = (Dali::RenderTaskList *)jarg1;
27753   arg2 = (unsigned int)jarg2;
27754   {
27755     try {
27756       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27757     } catch (std::out_of_range& e) {
27758       {
27759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (std::exception& e) {
27762       {
27763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27764       };
27765     } catch (Dali::DaliException e) {
27766       {
27767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27768       };
27769     } catch (...) {
27770       {
27771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27772       };
27773     }
27774   }
27775
27776   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27777   return jresult;
27778 }
27779
27780
27781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27782   int jresult ;
27783   int result;
27784
27785   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27786   jresult = (int)result;
27787   return jresult;
27788 }
27789
27790
27791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27792   int jresult ;
27793   int result;
27794
27795   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27796   jresult = (int)result;
27797   return jresult;
27798 }
27799
27800
27801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27802   int jresult ;
27803   int result;
27804
27805   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27806   jresult = (int)result;
27807   return jresult;
27808 }
27809
27810
27811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27812   int jresult ;
27813   int result;
27814
27815   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27816   jresult = (int)result;
27817   return jresult;
27818 }
27819
27820
27821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27822   void * jresult ;
27823   Dali::RenderTask::Property *result = 0 ;
27824
27825   {
27826     try {
27827       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27828     } catch (std::out_of_range& e) {
27829       {
27830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27831       };
27832     } catch (std::exception& e) {
27833       {
27834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27835       };
27836     } catch (Dali::DaliException e) {
27837       {
27838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27839       };
27840     } catch (...) {
27841       {
27842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27843       };
27844     }
27845   }
27846
27847   jresult = (void *)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27853   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27854
27855   arg1 = (Dali::RenderTask::Property *)jarg1;
27856   {
27857     try {
27858       delete arg1;
27859     } catch (std::out_of_range& e) {
27860       {
27861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27862       };
27863     } catch (std::exception& e) {
27864       {
27865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27866       };
27867     } catch (Dali::DaliException e) {
27868       {
27869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27870       };
27871     } catch (...) {
27872       {
27873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27874       };
27875     }
27876   }
27877
27878 }
27879
27880
27881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27882   void * jresult ;
27883   bool (*result)(Dali::Vector2 &) = 0 ;
27884
27885   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27886   jresult = (void *)result;
27887   return jresult;
27888 }
27889
27890
27891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27892   void * jresult ;
27893   bool (*result)(Dali::Vector2 &) = 0 ;
27894
27895   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27896   jresult = (void *)result;
27897   return jresult;
27898 }
27899
27900
27901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27902   unsigned int jresult ;
27903   bool result;
27904
27905   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27906   jresult = result;
27907   return jresult;
27908 }
27909
27910
27911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27912   unsigned int jresult ;
27913   bool result;
27914
27915   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27916   jresult = result;
27917   return jresult;
27918 }
27919
27920
27921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27922   void * jresult ;
27923   Dali::Vector4 *result = 0 ;
27924
27925   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27926   jresult = (void *)result;
27927   return jresult;
27928 }
27929
27930
27931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27932   unsigned int jresult ;
27933   bool result;
27934
27935   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27936   jresult = result;
27937   return jresult;
27938 }
27939
27940
27941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27942   unsigned int jresult ;
27943   bool result;
27944
27945   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27946   jresult = result;
27947   return jresult;
27948 }
27949
27950
27951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27952   unsigned int jresult ;
27953   unsigned int result;
27954
27955   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27956   jresult = result;
27957   return jresult;
27958 }
27959
27960
27961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27962   void * jresult ;
27963   Dali::RenderTask *result = 0 ;
27964
27965   {
27966     try {
27967       result = (Dali::RenderTask *)new Dali::RenderTask();
27968     } catch (std::out_of_range& e) {
27969       {
27970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27971       };
27972     } catch (std::exception& e) {
27973       {
27974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27975       };
27976     } catch (Dali::DaliException e) {
27977       {
27978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27979       };
27980     } catch (...) {
27981       {
27982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27983       };
27984     }
27985   }
27986
27987   jresult = (void *)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27993   void * jresult ;
27994   Dali::BaseHandle arg1 ;
27995   Dali::BaseHandle *argp1 ;
27996   Dali::RenderTask result;
27997
27998   argp1 = (Dali::BaseHandle *)jarg1;
27999   if (!argp1) {
28000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28001     return 0;
28002   }
28003   arg1 = *argp1;
28004   {
28005     try {
28006       result = Dali::RenderTask::DownCast(arg1);
28007     } catch (std::out_of_range& e) {
28008       {
28009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28010       };
28011     } catch (std::exception& e) {
28012       {
28013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (Dali::DaliException e) {
28016       {
28017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28018       };
28019     } catch (...) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28022       };
28023     }
28024   }
28025
28026   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28027   return jresult;
28028 }
28029
28030
28031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28032   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28033
28034   arg1 = (Dali::RenderTask *)jarg1;
28035   {
28036     try {
28037       delete arg1;
28038     } catch (std::out_of_range& e) {
28039       {
28040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28041       };
28042     } catch (std::exception& e) {
28043       {
28044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28045       };
28046     } catch (Dali::DaliException e) {
28047       {
28048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28049       };
28050     } catch (...) {
28051       {
28052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28053       };
28054     }
28055   }
28056
28057 }
28058
28059
28060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28061   void * jresult ;
28062   Dali::RenderTask *arg1 = 0 ;
28063   Dali::RenderTask *result = 0 ;
28064
28065   arg1 = (Dali::RenderTask *)jarg1;
28066   if (!arg1) {
28067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28068     return 0;
28069   }
28070   {
28071     try {
28072       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28073     } catch (std::out_of_range& e) {
28074       {
28075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28076       };
28077     } catch (std::exception& e) {
28078       {
28079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28080       };
28081     } catch (Dali::DaliException e) {
28082       {
28083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28084       };
28085     } catch (...) {
28086       {
28087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28088       };
28089     }
28090   }
28091
28092   jresult = (void *)result;
28093   return jresult;
28094 }
28095
28096
28097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28098   void * jresult ;
28099   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28100   Dali::RenderTask *arg2 = 0 ;
28101   Dali::RenderTask *result = 0 ;
28102
28103   arg1 = (Dali::RenderTask *)jarg1;
28104   arg2 = (Dali::RenderTask *)jarg2;
28105   if (!arg2) {
28106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28107     return 0;
28108   }
28109   {
28110     try {
28111       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28112     } catch (std::out_of_range& e) {
28113       {
28114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28115       };
28116     } catch (std::exception& e) {
28117       {
28118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28119       };
28120     } catch (Dali::DaliException e) {
28121       {
28122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28123       };
28124     } catch (...) {
28125       {
28126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28127       };
28128     }
28129   }
28130
28131   jresult = (void *)result;
28132   return jresult;
28133 }
28134
28135
28136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28137   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28138   Dali::Actor arg2 ;
28139   Dali::Actor *argp2 ;
28140
28141   arg1 = (Dali::RenderTask *)jarg1;
28142   argp2 = (Dali::Actor *)jarg2;
28143   if (!argp2) {
28144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28145     return ;
28146   }
28147   arg2 = *argp2;
28148   {
28149     try {
28150       (arg1)->SetSourceActor(arg2);
28151     } catch (std::out_of_range& e) {
28152       {
28153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28154       };
28155     } catch (std::exception& e) {
28156       {
28157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28158       };
28159     } catch (Dali::DaliException e) {
28160       {
28161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28162       };
28163     } catch (...) {
28164       {
28165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28166       };
28167     }
28168   }
28169
28170 }
28171
28172
28173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28174   void * jresult ;
28175   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28176   Dali::Actor result;
28177
28178   arg1 = (Dali::RenderTask *)jarg1;
28179   {
28180     try {
28181       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28182     } catch (std::out_of_range& e) {
28183       {
28184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28185       };
28186     } catch (std::exception& e) {
28187       {
28188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28189       };
28190     } catch (Dali::DaliException e) {
28191       {
28192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28197       };
28198     }
28199   }
28200
28201   jresult = new Dali::Actor((const Dali::Actor &)result);
28202   return jresult;
28203 }
28204
28205
28206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28207   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28208   bool arg2 ;
28209
28210   arg1 = (Dali::RenderTask *)jarg1;
28211   arg2 = jarg2 ? true : false;
28212   {
28213     try {
28214       (arg1)->SetExclusive(arg2);
28215     } catch (std::out_of_range& e) {
28216       {
28217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28218       };
28219     } catch (std::exception& e) {
28220       {
28221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28222       };
28223     } catch (Dali::DaliException e) {
28224       {
28225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28226       };
28227     } catch (...) {
28228       {
28229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28230       };
28231     }
28232   }
28233
28234 }
28235
28236
28237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28238   unsigned int jresult ;
28239   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28240   bool result;
28241
28242   arg1 = (Dali::RenderTask *)jarg1;
28243   {
28244     try {
28245       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28246     } catch (std::out_of_range& e) {
28247       {
28248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28249       };
28250     } catch (std::exception& e) {
28251       {
28252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28253       };
28254     } catch (Dali::DaliException e) {
28255       {
28256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28257       };
28258     } catch (...) {
28259       {
28260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28261       };
28262     }
28263   }
28264
28265   jresult = result;
28266   return jresult;
28267 }
28268
28269
28270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28271   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28272   bool arg2 ;
28273
28274   arg1 = (Dali::RenderTask *)jarg1;
28275   arg2 = jarg2 ? true : false;
28276   {
28277     try {
28278       (arg1)->SetInputEnabled(arg2);
28279     } catch (std::out_of_range& e) {
28280       {
28281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28282       };
28283     } catch (std::exception& e) {
28284       {
28285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28286       };
28287     } catch (Dali::DaliException e) {
28288       {
28289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28290       };
28291     } catch (...) {
28292       {
28293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28294       };
28295     }
28296   }
28297
28298 }
28299
28300
28301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28302   unsigned int jresult ;
28303   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28304   bool result;
28305
28306   arg1 = (Dali::RenderTask *)jarg1;
28307   {
28308     try {
28309       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28310     } catch (std::out_of_range& e) {
28311       {
28312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28313       };
28314     } catch (std::exception& e) {
28315       {
28316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (Dali::DaliException e) {
28319       {
28320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28325       };
28326     }
28327   }
28328
28329   jresult = result;
28330   return jresult;
28331 }
28332
28333
28334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28335   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28336   Dali::CameraActor arg2 ;
28337   Dali::CameraActor *argp2 ;
28338
28339   arg1 = (Dali::RenderTask *)jarg1;
28340   argp2 = (Dali::CameraActor *)jarg2;
28341   if (!argp2) {
28342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28343     return ;
28344   }
28345   arg2 = *argp2;
28346   {
28347     try {
28348       (arg1)->SetCameraActor(arg2);
28349     } catch (std::out_of_range& e) {
28350       {
28351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28352       };
28353     } catch (std::exception& e) {
28354       {
28355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28356       };
28357     } catch (Dali::DaliException e) {
28358       {
28359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28360       };
28361     } catch (...) {
28362       {
28363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28364       };
28365     }
28366   }
28367
28368 }
28369
28370
28371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28372   void * jresult ;
28373   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28374   Dali::CameraActor result;
28375
28376   arg1 = (Dali::RenderTask *)jarg1;
28377   {
28378     try {
28379       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28380     } catch (std::out_of_range& e) {
28381       {
28382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28383       };
28384     } catch (std::exception& e) {
28385       {
28386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28387       };
28388     } catch (Dali::DaliException e) {
28389       {
28390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28391       };
28392     } catch (...) {
28393       {
28394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28395       };
28396     }
28397   }
28398
28399   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28400   return jresult;
28401 }
28402
28403
28404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28405   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28406   Dali::FrameBuffer arg2 ;
28407   Dali::FrameBuffer *argp2 ;
28408
28409   arg1 = (Dali::RenderTask *)jarg1;
28410   argp2 = (Dali::FrameBuffer *)jarg2;
28411   if (!argp2) {
28412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28413     return ;
28414   }
28415   arg2 = *argp2;
28416   {
28417     try {
28418       (arg1)->SetFrameBuffer(arg2);
28419     } catch (std::out_of_range& e) {
28420       {
28421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28422       };
28423     } catch (std::exception& e) {
28424       {
28425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28426       };
28427     } catch (Dali::DaliException e) {
28428       {
28429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28430       };
28431     } catch (...) {
28432       {
28433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28434       };
28435     }
28436   }
28437
28438 }
28439
28440
28441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28442   void * jresult ;
28443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28444   Dali::FrameBuffer result;
28445
28446   arg1 = (Dali::RenderTask *)jarg1;
28447   {
28448     try {
28449       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28450     } catch (std::out_of_range& e) {
28451       {
28452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28453       };
28454     } catch (std::exception& e) {
28455       {
28456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28457       };
28458     } catch (Dali::DaliException e) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28461       };
28462     } catch (...) {
28463       {
28464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28465       };
28466     }
28467   }
28468
28469   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28470   return jresult;
28471 }
28472
28473
28474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28475   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28476   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28477
28478   arg1 = (Dali::RenderTask *)jarg1;
28479   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28480   {
28481     try {
28482       (arg1)->SetScreenToFrameBufferFunction(arg2);
28483     } catch (std::out_of_range& e) {
28484       {
28485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28486       };
28487     } catch (std::exception& e) {
28488       {
28489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28490       };
28491     } catch (Dali::DaliException e) {
28492       {
28493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28494       };
28495     } catch (...) {
28496       {
28497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28498       };
28499     }
28500   }
28501
28502 }
28503
28504
28505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28506   void * jresult ;
28507   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28508   Dali::RenderTask::ScreenToFrameBufferFunction result;
28509
28510   arg1 = (Dali::RenderTask *)jarg1;
28511   {
28512     try {
28513       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28514     } catch (std::out_of_range& e) {
28515       {
28516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28517       };
28518     } catch (std::exception& e) {
28519       {
28520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28521       };
28522     } catch (Dali::DaliException e) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28525       };
28526     } catch (...) {
28527       {
28528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28529       };
28530     }
28531   }
28532
28533   jresult = (void *)result;
28534   return jresult;
28535 }
28536
28537
28538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28539   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28540   Dali::Actor arg2 ;
28541   Dali::Actor *argp2 ;
28542
28543   arg1 = (Dali::RenderTask *)jarg1;
28544   argp2 = (Dali::Actor *)jarg2;
28545   if (!argp2) {
28546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28547     return ;
28548   }
28549   arg2 = *argp2;
28550   {
28551     try {
28552       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28553     } catch (std::out_of_range& e) {
28554       {
28555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28556       };
28557     } catch (std::exception& e) {
28558       {
28559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28560       };
28561     } catch (Dali::DaliException e) {
28562       {
28563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28564       };
28565     } catch (...) {
28566       {
28567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28568       };
28569     }
28570   }
28571
28572 }
28573
28574
28575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28576   void * jresult ;
28577   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28578   Dali::Actor result;
28579
28580   arg1 = (Dali::RenderTask *)jarg1;
28581   {
28582     try {
28583       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28584     } catch (std::out_of_range& e) {
28585       {
28586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28587       };
28588     } catch (std::exception& e) {
28589       {
28590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28591       };
28592     } catch (Dali::DaliException e) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28595       };
28596     } catch (...) {
28597       {
28598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28599       };
28600     }
28601   }
28602
28603   jresult = new Dali::Actor((const Dali::Actor &)result);
28604   return jresult;
28605 }
28606
28607
28608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28609   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28610   Dali::Vector2 arg2 ;
28611   Dali::Vector2 *argp2 ;
28612
28613   arg1 = (Dali::RenderTask *)jarg1;
28614   argp2 = (Dali::Vector2 *)jarg2;
28615   if (!argp2) {
28616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28617     return ;
28618   }
28619   arg2 = *argp2;
28620   {
28621     try {
28622       (arg1)->SetViewportPosition(arg2);
28623     } catch (std::out_of_range& e) {
28624       {
28625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28626       };
28627     } catch (std::exception& e) {
28628       {
28629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28630       };
28631     } catch (Dali::DaliException e) {
28632       {
28633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28634       };
28635     } catch (...) {
28636       {
28637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28638       };
28639     }
28640   }
28641
28642 }
28643
28644
28645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28646   void * jresult ;
28647   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28648   Dali::Vector2 result;
28649
28650   arg1 = (Dali::RenderTask *)jarg1;
28651   {
28652     try {
28653       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28654     } catch (std::out_of_range& e) {
28655       {
28656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28657       };
28658     } catch (std::exception& e) {
28659       {
28660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28661       };
28662     } catch (Dali::DaliException e) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28669       };
28670     }
28671   }
28672
28673   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28674   return jresult;
28675 }
28676
28677
28678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28679   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28680   Dali::Vector2 arg2 ;
28681   Dali::Vector2 *argp2 ;
28682
28683   arg1 = (Dali::RenderTask *)jarg1;
28684   argp2 = (Dali::Vector2 *)jarg2;
28685   if (!argp2) {
28686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28687     return ;
28688   }
28689   arg2 = *argp2;
28690   {
28691     try {
28692       (arg1)->SetViewportSize(arg2);
28693     } catch (std::out_of_range& e) {
28694       {
28695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (std::exception& e) {
28698       {
28699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28700       };
28701     } catch (Dali::DaliException e) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28704       };
28705     } catch (...) {
28706       {
28707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28708       };
28709     }
28710   }
28711
28712 }
28713
28714
28715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28716   void * jresult ;
28717   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28718   Dali::Vector2 result;
28719
28720   arg1 = (Dali::RenderTask *)jarg1;
28721   {
28722     try {
28723       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28724     } catch (std::out_of_range& e) {
28725       {
28726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28727       };
28728     } catch (std::exception& e) {
28729       {
28730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28731       };
28732     } catch (Dali::DaliException e) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28735       };
28736     } catch (...) {
28737       {
28738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28739       };
28740     }
28741   }
28742
28743   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28744   return jresult;
28745 }
28746
28747
28748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28749   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28750   Dali::Viewport arg2 ;
28751   Dali::Viewport *argp2 ;
28752
28753   arg1 = (Dali::RenderTask *)jarg1;
28754   argp2 = (Dali::Viewport *)jarg2;
28755   if (!argp2) {
28756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28757     return ;
28758   }
28759   arg2 = *argp2;
28760   {
28761     try {
28762       (arg1)->SetViewport(arg2);
28763     } catch (std::out_of_range& e) {
28764       {
28765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28766       };
28767     } catch (std::exception& e) {
28768       {
28769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28770       };
28771     } catch (Dali::DaliException e) {
28772       {
28773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28774       };
28775     } catch (...) {
28776       {
28777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28778       };
28779     }
28780   }
28781
28782 }
28783
28784
28785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28786   void * jresult ;
28787   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28788   Dali::Viewport result;
28789
28790   arg1 = (Dali::RenderTask *)jarg1;
28791   {
28792     try {
28793       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28794     } catch (std::out_of_range& e) {
28795       {
28796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28797       };
28798     } catch (std::exception& e) {
28799       {
28800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28801       };
28802     } catch (Dali::DaliException e) {
28803       {
28804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28805       };
28806     } catch (...) {
28807       {
28808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28809       };
28810     }
28811   }
28812
28813   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28814   return jresult;
28815 }
28816
28817
28818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28819   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28820   Dali::Vector4 *arg2 = 0 ;
28821
28822   arg1 = (Dali::RenderTask *)jarg1;
28823   arg2 = (Dali::Vector4 *)jarg2;
28824   if (!arg2) {
28825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28826     return ;
28827   }
28828   {
28829     try {
28830       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28831     } catch (std::out_of_range& e) {
28832       {
28833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28834       };
28835     } catch (std::exception& e) {
28836       {
28837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28838       };
28839     } catch (Dali::DaliException e) {
28840       {
28841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28842       };
28843     } catch (...) {
28844       {
28845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28846       };
28847     }
28848   }
28849
28850 }
28851
28852
28853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28854   void * jresult ;
28855   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28856   Dali::Vector4 result;
28857
28858   arg1 = (Dali::RenderTask *)jarg1;
28859   {
28860     try {
28861       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28862     } catch (std::out_of_range& e) {
28863       {
28864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28865       };
28866     } catch (std::exception& e) {
28867       {
28868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28869       };
28870     } catch (Dali::DaliException e) {
28871       {
28872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28873       };
28874     } catch (...) {
28875       {
28876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28877       };
28878     }
28879   }
28880
28881   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28882   return jresult;
28883 }
28884
28885
28886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28887   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28888   bool arg2 ;
28889
28890   arg1 = (Dali::RenderTask *)jarg1;
28891   arg2 = jarg2 ? true : false;
28892   {
28893     try {
28894       (arg1)->SetClearEnabled(arg2);
28895     } catch (std::out_of_range& e) {
28896       {
28897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28898       };
28899     } catch (std::exception& e) {
28900       {
28901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28902       };
28903     } catch (Dali::DaliException e) {
28904       {
28905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28906       };
28907     } catch (...) {
28908       {
28909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28910       };
28911     }
28912   }
28913
28914 }
28915
28916
28917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28918   unsigned int jresult ;
28919   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28920   bool result;
28921
28922   arg1 = (Dali::RenderTask *)jarg1;
28923   {
28924     try {
28925       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28926     } catch (std::out_of_range& e) {
28927       {
28928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28929       };
28930     } catch (std::exception& e) {
28931       {
28932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28933       };
28934     } catch (Dali::DaliException e) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28937       };
28938     } catch (...) {
28939       {
28940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28941       };
28942     }
28943   }
28944
28945   jresult = result;
28946   return jresult;
28947 }
28948
28949
28950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28951   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28952   bool arg2 ;
28953
28954   arg1 = (Dali::RenderTask *)jarg1;
28955   arg2 = jarg2 ? true : false;
28956   {
28957     try {
28958       (arg1)->SetCullMode(arg2);
28959     } catch (std::out_of_range& e) {
28960       {
28961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28962       };
28963     } catch (std::exception& e) {
28964       {
28965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (Dali::DaliException e) {
28968       {
28969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28974       };
28975     }
28976   }
28977
28978 }
28979
28980
28981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28982   unsigned int jresult ;
28983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28984   bool result;
28985
28986   arg1 = (Dali::RenderTask *)jarg1;
28987   {
28988     try {
28989       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28990     } catch (std::out_of_range& e) {
28991       {
28992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28993       };
28994     } catch (std::exception& e) {
28995       {
28996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (Dali::DaliException e) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29001       };
29002     } catch (...) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29005       };
29006     }
29007   }
29008
29009   jresult = result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29016   unsigned int arg2 ;
29017
29018   arg1 = (Dali::RenderTask *)jarg1;
29019   arg2 = (unsigned int)jarg2;
29020   {
29021     try {
29022       (arg1)->SetRefreshRate(arg2);
29023     } catch (std::out_of_range& e) {
29024       {
29025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (std::exception& e) {
29028       {
29029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29030       };
29031     } catch (Dali::DaliException e) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29034       };
29035     } catch (...) {
29036       {
29037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29038       };
29039     }
29040   }
29041
29042 }
29043
29044
29045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29046   unsigned int jresult ;
29047   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29048   unsigned int result;
29049
29050   arg1 = (Dali::RenderTask *)jarg1;
29051   {
29052     try {
29053       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29061       };
29062     } catch (Dali::DaliException e) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29065       };
29066     } catch (...) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29069       };
29070     }
29071   }
29072
29073   jresult = result;
29074   return jresult;
29075 }
29076
29077
29078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29079   unsigned int jresult ;
29080   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29081   Dali::Vector3 *arg2 = 0 ;
29082   float *arg3 = 0 ;
29083   float *arg4 = 0 ;
29084   bool result;
29085
29086   arg1 = (Dali::RenderTask *)jarg1;
29087   arg2 = (Dali::Vector3 *)jarg2;
29088   if (!arg2) {
29089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29090     return 0;
29091   }
29092   arg3 = (float *)jarg3;
29093   arg4 = (float *)jarg4;
29094   {
29095     try {
29096       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29097     } catch (std::out_of_range& e) {
29098       {
29099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29100       };
29101     } catch (std::exception& e) {
29102       {
29103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29104       };
29105     } catch (Dali::DaliException e) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29108       };
29109     } catch (...) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29112       };
29113     }
29114   }
29115
29116   jresult = result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29122   unsigned int jresult ;
29123   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29124   Dali::Actor arg2 ;
29125   float arg3 ;
29126   float arg4 ;
29127   float *arg5 = 0 ;
29128   float *arg6 = 0 ;
29129   Dali::Actor *argp2 ;
29130   bool result;
29131
29132   arg1 = (Dali::RenderTask *)jarg1;
29133   argp2 = (Dali::Actor *)jarg2;
29134   if (!argp2) {
29135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29136     return 0;
29137   }
29138   arg2 = *argp2;
29139   arg3 = (float)jarg3;
29140   arg4 = (float)jarg4;
29141   arg5 = (float *)jarg5;
29142   arg6 = (float *)jarg6;
29143   {
29144     try {
29145       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29146     } catch (std::out_of_range& e) {
29147       {
29148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29149       };
29150     } catch (std::exception& e) {
29151       {
29152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29153       };
29154     } catch (Dali::DaliException e) {
29155       {
29156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29157       };
29158     } catch (...) {
29159       {
29160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29161       };
29162     }
29163   }
29164
29165   jresult = result;
29166   return jresult;
29167 }
29168
29169
29170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29171   void * jresult ;
29172   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29173   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29174
29175   arg1 = (Dali::RenderTask *)jarg1;
29176   {
29177     try {
29178       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29179     } catch (std::out_of_range& e) {
29180       {
29181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29182       };
29183     } catch (std::exception& e) {
29184       {
29185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29186       };
29187     } catch (Dali::DaliException e) {
29188       {
29189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29190       };
29191     } catch (...) {
29192       {
29193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29194       };
29195     }
29196   }
29197
29198   jresult = (void *)result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29204   void * jresult ;
29205   int arg1 ;
29206   Dali::TouchPoint::State arg2 ;
29207   float arg3 ;
29208   float arg4 ;
29209   Dali::TouchPoint *result = 0 ;
29210
29211   arg1 = (int)jarg1;
29212   arg2 = (Dali::TouchPoint::State)jarg2;
29213   arg3 = (float)jarg3;
29214   arg4 = (float)jarg4;
29215   {
29216     try {
29217       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29218     } catch (std::out_of_range& e) {
29219       {
29220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29221       };
29222     } catch (std::exception& e) {
29223       {
29224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29225       };
29226     } catch (Dali::DaliException e) {
29227       {
29228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29229       };
29230     } catch (...) {
29231       {
29232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29233       };
29234     }
29235   }
29236
29237   jresult = (void *)result;
29238   return jresult;
29239 }
29240
29241
29242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29243   void * jresult ;
29244   int arg1 ;
29245   Dali::TouchPoint::State arg2 ;
29246   float arg3 ;
29247   float arg4 ;
29248   float arg5 ;
29249   float arg6 ;
29250   Dali::TouchPoint *result = 0 ;
29251
29252   arg1 = (int)jarg1;
29253   arg2 = (Dali::TouchPoint::State)jarg2;
29254   arg3 = (float)jarg3;
29255   arg4 = (float)jarg4;
29256   arg5 = (float)jarg5;
29257   arg6 = (float)jarg6;
29258   {
29259     try {
29260       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29261     } catch (std::out_of_range& e) {
29262       {
29263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (std::exception& e) {
29266       {
29267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29268       };
29269     } catch (Dali::DaliException e) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29272       };
29273     } catch (...) {
29274       {
29275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29276       };
29277     }
29278   }
29279
29280   jresult = (void *)result;
29281   return jresult;
29282 }
29283
29284
29285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29286   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29287
29288   arg1 = (Dali::TouchPoint *)jarg1;
29289   {
29290     try {
29291       delete arg1;
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29307       };
29308     }
29309   }
29310
29311 }
29312
29313
29314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29315   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29316   int arg2 ;
29317
29318   arg1 = (Dali::TouchPoint *)jarg1;
29319   arg2 = (int)jarg2;
29320   if (arg1) (arg1)->deviceId = arg2;
29321 }
29322
29323
29324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29325   int jresult ;
29326   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29327   int result;
29328
29329   arg1 = (Dali::TouchPoint *)jarg1;
29330   result = (int) ((arg1)->deviceId);
29331   jresult = result;
29332   return jresult;
29333 }
29334
29335
29336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29337   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29338   Dali::TouchPoint::State arg2 ;
29339
29340   arg1 = (Dali::TouchPoint *)jarg1;
29341   arg2 = (Dali::TouchPoint::State)jarg2;
29342   if (arg1) (arg1)->state = arg2;
29343 }
29344
29345
29346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29347   int jresult ;
29348   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29349   Dali::TouchPoint::State result;
29350
29351   arg1 = (Dali::TouchPoint *)jarg1;
29352   result = (Dali::TouchPoint::State) ((arg1)->state);
29353   jresult = (int)result;
29354   return jresult;
29355 }
29356
29357
29358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29359   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29360   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29361
29362   arg1 = (Dali::TouchPoint *)jarg1;
29363   arg2 = (Dali::Actor *)jarg2;
29364   if (arg1) (arg1)->hitActor = *arg2;
29365 }
29366
29367
29368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29369   void * jresult ;
29370   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29371   Dali::Actor *result = 0 ;
29372
29373   arg1 = (Dali::TouchPoint *)jarg1;
29374   result = (Dali::Actor *)& ((arg1)->hitActor);
29375   jresult = (void *)result;
29376   return jresult;
29377 }
29378
29379
29380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29381   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29382   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29383
29384   arg1 = (Dali::TouchPoint *)jarg1;
29385   arg2 = (Dali::Vector2 *)jarg2;
29386   if (arg1) (arg1)->local = *arg2;
29387 }
29388
29389
29390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29391   void * jresult ;
29392   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29393   Dali::Vector2 *result = 0 ;
29394
29395   arg1 = (Dali::TouchPoint *)jarg1;
29396   result = (Dali::Vector2 *)& ((arg1)->local);
29397   jresult = (void *)result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29403   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29404   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29405
29406   arg1 = (Dali::TouchPoint *)jarg1;
29407   arg2 = (Dali::Vector2 *)jarg2;
29408   if (arg1) (arg1)->screen = *arg2;
29409 }
29410
29411
29412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29413   void * jresult ;
29414   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29415   Dali::Vector2 *result = 0 ;
29416
29417   arg1 = (Dali::TouchPoint *)jarg1;
29418   result = (Dali::Vector2 *)& ((arg1)->screen);
29419   jresult = (void *)result;
29420   return jresult;
29421 }
29422
29423
29424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29425   void * jresult ;
29426   Dali::TouchEvent *result = 0 ;
29427
29428   {
29429     try {
29430       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29431     } catch (std::out_of_range& e) {
29432       {
29433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (std::exception& e) {
29436       {
29437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29438       };
29439     } catch (Dali::DaliException e) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29442       };
29443     } catch (...) {
29444       {
29445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29446       };
29447     }
29448   }
29449
29450   jresult = (void *)result;
29451   return jresult;
29452 }
29453
29454
29455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29456   void * jresult ;
29457   Dali::TouchEvent *arg1 = 0 ;
29458   Dali::TouchEvent *result = 0 ;
29459
29460   arg1 = (Dali::TouchEvent *)jarg1;
29461   if (!arg1) {
29462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29463     return 0;
29464   }
29465   {
29466     try {
29467       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29468     } catch (std::out_of_range& e) {
29469       {
29470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29471       };
29472     } catch (std::exception& e) {
29473       {
29474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29475       };
29476     } catch (Dali::DaliException e) {
29477       {
29478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29479       };
29480     } catch (...) {
29481       {
29482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29483       };
29484     }
29485   }
29486
29487   jresult = (void *)result;
29488   return jresult;
29489 }
29490
29491
29492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29493   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29494
29495   arg1 = (Dali::TouchEvent *)jarg1;
29496   {
29497     try {
29498       delete arg1;
29499     } catch (std::out_of_range& e) {
29500       {
29501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29502       };
29503     } catch (std::exception& e) {
29504       {
29505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29506       };
29507     } catch (Dali::DaliException e) {
29508       {
29509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29510       };
29511     } catch (...) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29514       };
29515     }
29516   }
29517
29518 }
29519
29520
29521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29522   void * jresult ;
29523   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29524   Dali::TouchEvent *arg2 = 0 ;
29525   Dali::TouchEvent *result = 0 ;
29526
29527   arg1 = (Dali::TouchEvent *)jarg1;
29528   arg2 = (Dali::TouchEvent *)jarg2;
29529   if (!arg2) {
29530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29531     return 0;
29532   }
29533   {
29534     try {
29535       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29536     } catch (std::out_of_range& e) {
29537       {
29538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (std::exception& e) {
29541       {
29542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29543       };
29544     } catch (Dali::DaliException e) {
29545       {
29546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29547       };
29548     } catch (...) {
29549       {
29550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29551       };
29552     }
29553   }
29554
29555   jresult = (void *)result;
29556   return jresult;
29557 }
29558
29559
29560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29561   unsigned long jresult ;
29562   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29563   unsigned long result;
29564
29565   arg1 = (Dali::TouchEvent *)jarg1;
29566   {
29567     try {
29568       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29569     } catch (std::out_of_range& e) {
29570       {
29571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29572       };
29573     } catch (std::exception& e) {
29574       {
29575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29576       };
29577     } catch (Dali::DaliException e) {
29578       {
29579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29580       };
29581     } catch (...) {
29582       {
29583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29584       };
29585     }
29586   }
29587
29588   jresult = (unsigned long)result;
29589   return jresult;
29590 }
29591
29592
29593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29594   unsigned long jresult ;
29595   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29596   std::size_t result;
29597
29598   arg1 = (Dali::TouchEvent *)jarg1;
29599   {
29600     try {
29601       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29602     } catch (std::out_of_range& e) {
29603       {
29604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29605       };
29606     } catch (std::exception& e) {
29607       {
29608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29609       };
29610     } catch (Dali::DaliException e) {
29611       {
29612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29613       };
29614     } catch (...) {
29615       {
29616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29617       };
29618     }
29619   }
29620
29621   jresult = (unsigned long)result;
29622   return jresult;
29623 }
29624
29625
29626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29627   int jresult ;
29628   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29629   std::size_t arg2 ;
29630   int32_t result;
29631
29632   arg1 = (Dali::TouchEvent *)jarg1;
29633   arg2 = (std::size_t)jarg2;
29634   {
29635     try {
29636       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29637     } catch (std::out_of_range& e) {
29638       {
29639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (std::exception& e) {
29642       {
29643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29644       };
29645     } catch (Dali::DaliException e) {
29646       {
29647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29648       };
29649     } catch (...) {
29650       {
29651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29652       };
29653     }
29654   }
29655
29656   jresult = result;
29657   return jresult;
29658 }
29659
29660
29661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29662   int jresult ;
29663   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29664   std::size_t arg2 ;
29665   Dali::PointState::Type result;
29666
29667   arg1 = (Dali::TouchEvent *)jarg1;
29668   arg2 = (std::size_t)jarg2;
29669   {
29670     try {
29671       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29672     } catch (std::out_of_range& e) {
29673       {
29674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29675       };
29676     } catch (std::exception& e) {
29677       {
29678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29679       };
29680     } catch (Dali::DaliException e) {
29681       {
29682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29683       };
29684     } catch (...) {
29685       {
29686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29687       };
29688     }
29689   }
29690
29691   jresult = (int)result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29697   void * jresult ;
29698   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29699   std::size_t arg2 ;
29700   Dali::Actor result;
29701
29702   arg1 = (Dali::TouchEvent *)jarg1;
29703   arg2 = (std::size_t)jarg2;
29704   {
29705     try {
29706       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29707     } catch (std::out_of_range& e) {
29708       {
29709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (std::exception& e) {
29712       {
29713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29714       };
29715     } catch (Dali::DaliException e) {
29716       {
29717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29718       };
29719     } catch (...) {
29720       {
29721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29722       };
29723     }
29724   }
29725
29726   jresult = new Dali::Actor((const Dali::Actor &)result);
29727   return jresult;
29728 }
29729
29730
29731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29732   void * jresult ;
29733   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29734   std::size_t arg2 ;
29735   Dali::Vector2 *result = 0 ;
29736
29737   arg1 = (Dali::TouchEvent *)jarg1;
29738   arg2 = (std::size_t)jarg2;
29739   {
29740     try {
29741       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29742     } catch (std::out_of_range& e) {
29743       {
29744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (std::exception& e) {
29747       {
29748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29749       };
29750     } catch (Dali::DaliException e) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29753       };
29754     } catch (...) {
29755       {
29756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29757       };
29758     }
29759   }
29760
29761   jresult = (void *)result;
29762   return jresult;
29763 }
29764
29765
29766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29767   void * jresult ;
29768   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29769   std::size_t arg2 ;
29770   Dali::Vector2 *result = 0 ;
29771
29772   arg1 = (Dali::TouchEvent *)jarg1;
29773   arg2 = (std::size_t)jarg2;
29774   {
29775     try {
29776       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29777     } catch (std::out_of_range& e) {
29778       {
29779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29780       };
29781     } catch (std::exception& e) {
29782       {
29783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29784       };
29785     } catch (Dali::DaliException e) {
29786       {
29787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29788       };
29789     } catch (...) {
29790       {
29791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29792       };
29793     }
29794   }
29795
29796   jresult = (void *)result;
29797   return jresult;
29798 }
29799
29800
29801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29802   float jresult ;
29803   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29804   std::size_t arg2 ;
29805   float result;
29806
29807   arg1 = (Dali::TouchEvent *)jarg1;
29808   arg2 = (std::size_t)jarg2;
29809   {
29810     try {
29811       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29812     } catch (std::out_of_range& e) {
29813       {
29814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (std::exception& e) {
29817       {
29818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29819       };
29820     } catch (Dali::DaliException e) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29823       };
29824     } catch (...) {
29825       {
29826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29827       };
29828     }
29829   }
29830
29831   jresult = result;
29832   return jresult;
29833 }
29834
29835
29836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29837   void * jresult ;
29838   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29839   std::size_t arg2 ;
29840   Dali::Vector2 *result = 0 ;
29841
29842   arg1 = (Dali::TouchEvent *)jarg1;
29843   arg2 = (std::size_t)jarg2;
29844   {
29845     try {
29846       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29847     } catch (std::out_of_range& e) {
29848       {
29849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (std::exception& e) {
29852       {
29853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29854       };
29855     } catch (Dali::DaliException e) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29858       };
29859     } catch (...) {
29860       {
29861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29862       };
29863     }
29864   }
29865
29866   jresult = (void *)result;
29867   return jresult;
29868 }
29869
29870
29871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29872   float jresult ;
29873   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29874   std::size_t arg2 ;
29875   float result;
29876
29877   arg1 = (Dali::TouchEvent *)jarg1;
29878   arg2 = (std::size_t)jarg2;
29879   {
29880     try {
29881       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29882     } catch (std::out_of_range& e) {
29883       {
29884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29885       };
29886     } catch (std::exception& e) {
29887       {
29888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29889       };
29890     } catch (Dali::DaliException e) {
29891       {
29892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29893       };
29894     } catch (...) {
29895       {
29896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29897       };
29898     }
29899   }
29900
29901   jresult = result;
29902   return jresult;
29903 }
29904
29905
29906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29907   void * jresult ;
29908   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29909   std::size_t arg2 ;
29910   Dali::Degree result;
29911
29912   arg1 = (Dali::TouchEvent *)jarg1;
29913   arg2 = (std::size_t)jarg2;
29914   {
29915     try {
29916       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29917     } catch (std::out_of_range& e) {
29918       {
29919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (std::exception& e) {
29922       {
29923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29924       };
29925     } catch (Dali::DaliException e) {
29926       {
29927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29928       };
29929     } catch (...) {
29930       {
29931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29932       };
29933     }
29934   }
29935
29936   jresult = new Dali::Degree((const Dali::Degree &)result);
29937   return jresult;
29938 }
29939
29940
29941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29942   int jresult ;
29943   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29944   std::size_t arg2 ;
29945   Dali::MouseButton::Type result;
29946
29947   arg1 = (Dali::TouchEvent *)jarg1;
29948   arg2 = (std::size_t)jarg2;
29949   {
29950     try {
29951       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29952     } catch (std::out_of_range& e) {
29953       {
29954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29955       };
29956     } catch (std::exception& e) {
29957       {
29958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29959       };
29960     } catch (Dali::DaliException e) {
29961       {
29962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29963       };
29964     } catch (...) {
29965       {
29966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29967       };
29968     }
29969   }
29970
29971   jresult = static_cast< int >(result);
29972   return jresult;
29973 }
29974
29975
29976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29977   void * jresult ;
29978   Dali::GestureDetector *result = 0 ;
29979
29980   {
29981     try {
29982       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29983     } catch (std::out_of_range& e) {
29984       {
29985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29986       };
29987     } catch (std::exception& e) {
29988       {
29989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29990       };
29991     } catch (Dali::DaliException e) {
29992       {
29993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29994       };
29995     } catch (...) {
29996       {
29997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29998       };
29999     }
30000   }
30001
30002   jresult = (void *)result;
30003   return jresult;
30004 }
30005
30006
30007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30008   void * jresult ;
30009   Dali::BaseHandle arg1 ;
30010   Dali::BaseHandle *argp1 ;
30011   Dali::GestureDetector result;
30012
30013   argp1 = (Dali::BaseHandle *)jarg1;
30014   if (!argp1) {
30015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30016     return 0;
30017   }
30018   arg1 = *argp1;
30019   {
30020     try {
30021       result = Dali::GestureDetector::DownCast(arg1);
30022     } catch (std::out_of_range& e) {
30023       {
30024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30025       };
30026     } catch (std::exception& e) {
30027       {
30028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30029       };
30030     } catch (Dali::DaliException e) {
30031       {
30032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30033       };
30034     } catch (...) {
30035       {
30036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30037       };
30038     }
30039   }
30040
30041   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30042   return jresult;
30043 }
30044
30045
30046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30047   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30048
30049   arg1 = (Dali::GestureDetector *)jarg1;
30050   {
30051     try {
30052       delete arg1;
30053     } catch (std::out_of_range& e) {
30054       {
30055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30056       };
30057     } catch (std::exception& e) {
30058       {
30059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30060       };
30061     } catch (Dali::DaliException e) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30064       };
30065     } catch (...) {
30066       {
30067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30068       };
30069     }
30070   }
30071
30072 }
30073
30074
30075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30076   void * jresult ;
30077   Dali::GestureDetector *arg1 = 0 ;
30078   Dali::GestureDetector *result = 0 ;
30079
30080   arg1 = (Dali::GestureDetector *)jarg1;
30081   if (!arg1) {
30082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30083     return 0;
30084   }
30085   {
30086     try {
30087       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30088     } catch (std::out_of_range& e) {
30089       {
30090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30091       };
30092     } catch (std::exception& e) {
30093       {
30094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30095       };
30096     } catch (Dali::DaliException e) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30099       };
30100     } catch (...) {
30101       {
30102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30103       };
30104     }
30105   }
30106
30107   jresult = (void *)result;
30108   return jresult;
30109 }
30110
30111
30112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30113   void * jresult ;
30114   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30115   Dali::GestureDetector *arg2 = 0 ;
30116   Dali::GestureDetector *result = 0 ;
30117
30118   arg1 = (Dali::GestureDetector *)jarg1;
30119   arg2 = (Dali::GestureDetector *)jarg2;
30120   if (!arg2) {
30121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30122     return 0;
30123   }
30124   {
30125     try {
30126       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30127     } catch (std::out_of_range& e) {
30128       {
30129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30130       };
30131     } catch (std::exception& e) {
30132       {
30133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30134       };
30135     } catch (Dali::DaliException e) {
30136       {
30137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30138       };
30139     } catch (...) {
30140       {
30141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30142       };
30143     }
30144   }
30145
30146   jresult = (void *)result;
30147   return jresult;
30148 }
30149
30150
30151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30152   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30153   Dali::Actor arg2 ;
30154   Dali::Actor *argp2 ;
30155
30156   arg1 = (Dali::GestureDetector *)jarg1;
30157   argp2 = (Dali::Actor *)jarg2;
30158   if (!argp2) {
30159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30160     return ;
30161   }
30162   arg2 = *argp2;
30163   {
30164     try {
30165       (arg1)->Attach(arg2);
30166     } catch (std::out_of_range& e) {
30167       {
30168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30169       };
30170     } catch (std::exception& e) {
30171       {
30172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30173       };
30174     } catch (Dali::DaliException e) {
30175       {
30176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30177       };
30178     } catch (...) {
30179       {
30180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30181       };
30182     }
30183   }
30184
30185 }
30186
30187
30188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30189   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30190   Dali::Actor arg2 ;
30191   Dali::Actor *argp2 ;
30192
30193   arg1 = (Dali::GestureDetector *)jarg1;
30194   argp2 = (Dali::Actor *)jarg2;
30195   if (!argp2) {
30196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30197     return ;
30198   }
30199   arg2 = *argp2;
30200   {
30201     try {
30202       (arg1)->Detach(arg2);
30203     } catch (std::out_of_range& e) {
30204       {
30205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30206       };
30207     } catch (std::exception& e) {
30208       {
30209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30210       };
30211     } catch (Dali::DaliException e) {
30212       {
30213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30214       };
30215     } catch (...) {
30216       {
30217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30218       };
30219     }
30220   }
30221
30222 }
30223
30224
30225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30226   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30227
30228   arg1 = (Dali::GestureDetector *)jarg1;
30229   {
30230     try {
30231       (arg1)->DetachAll();
30232     } catch (std::out_of_range& e) {
30233       {
30234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30235       };
30236     } catch (std::exception& e) {
30237       {
30238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30239       };
30240     } catch (Dali::DaliException e) {
30241       {
30242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30243       };
30244     } catch (...) {
30245       {
30246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30247       };
30248     }
30249   }
30250
30251 }
30252
30253
30254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30255   unsigned long jresult ;
30256   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30257   size_t result;
30258
30259   arg1 = (Dali::GestureDetector *)jarg1;
30260   {
30261     try {
30262       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30263     } catch (std::out_of_range& e) {
30264       {
30265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30266       };
30267     } catch (std::exception& e) {
30268       {
30269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30270       };
30271     } catch (Dali::DaliException e) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30274       };
30275     } catch (...) {
30276       {
30277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30278       };
30279     }
30280   }
30281
30282   jresult = (unsigned long)result;
30283   return jresult;
30284 }
30285
30286
30287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30288   void * jresult ;
30289   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30290   size_t arg2 ;
30291   Dali::Actor result;
30292
30293   arg1 = (Dali::GestureDetector *)jarg1;
30294   arg2 = (size_t)jarg2;
30295   {
30296     try {
30297       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30298     } catch (std::out_of_range& e) {
30299       {
30300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30301       };
30302     } catch (std::exception& e) {
30303       {
30304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30305       };
30306     } catch (Dali::DaliException e) {
30307       {
30308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30309       };
30310     } catch (...) {
30311       {
30312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30313       };
30314     }
30315   }
30316
30317   jresult = new Dali::Actor((const Dali::Actor &)result);
30318   return jresult;
30319 }
30320
30321
30322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30323   void * jresult ;
30324   Dali::Gesture *arg1 = 0 ;
30325   Dali::Gesture *result = 0 ;
30326
30327   arg1 = (Dali::Gesture *)jarg1;
30328   if (!arg1) {
30329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30330     return 0;
30331   }
30332   {
30333     try {
30334       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30335     } catch (std::out_of_range& e) {
30336       {
30337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30338       };
30339     } catch (std::exception& e) {
30340       {
30341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30342       };
30343     } catch (Dali::DaliException e) {
30344       {
30345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30346       };
30347     } catch (...) {
30348       {
30349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30350       };
30351     }
30352   }
30353
30354   jresult = (void *)result;
30355   return jresult;
30356 }
30357
30358
30359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30360   void * jresult ;
30361   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30362   Dali::Gesture *arg2 = 0 ;
30363   Dali::Gesture *result = 0 ;
30364
30365   arg1 = (Dali::Gesture *)jarg1;
30366   arg2 = (Dali::Gesture *)jarg2;
30367   if (!arg2) {
30368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30369     return 0;
30370   }
30371   {
30372     try {
30373       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30374     } catch (std::out_of_range& e) {
30375       {
30376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30377       };
30378     } catch (std::exception& e) {
30379       {
30380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30381       };
30382     } catch (Dali::DaliException e) {
30383       {
30384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30385       };
30386     } catch (...) {
30387       {
30388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30389       };
30390     }
30391   }
30392
30393   jresult = (void *)result;
30394   return jresult;
30395 }
30396
30397
30398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30399   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30400
30401   arg1 = (Dali::Gesture *)jarg1;
30402   {
30403     try {
30404       delete arg1;
30405     } catch (std::out_of_range& e) {
30406       {
30407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30408       };
30409     } catch (std::exception& e) {
30410       {
30411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30412       };
30413     } catch (Dali::DaliException e) {
30414       {
30415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30420       };
30421     }
30422   }
30423
30424 }
30425
30426
30427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30428   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30429   Dali::Gesture::Type arg2 ;
30430
30431   arg1 = (Dali::Gesture *)jarg1;
30432   arg2 = (Dali::Gesture::Type)jarg2;
30433   if (arg1) (arg1)->type = arg2;
30434 }
30435
30436
30437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30438   int jresult ;
30439   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30440   Dali::Gesture::Type result;
30441
30442   arg1 = (Dali::Gesture *)jarg1;
30443   result = (Dali::Gesture::Type) ((arg1)->type);
30444   jresult = (int)result;
30445   return jresult;
30446 }
30447
30448
30449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30450   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30451   Dali::Gesture::State arg2 ;
30452
30453   arg1 = (Dali::Gesture *)jarg1;
30454   arg2 = (Dali::Gesture::State)jarg2;
30455   if (arg1) (arg1)->state = arg2;
30456 }
30457
30458
30459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30460   int jresult ;
30461   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30462   Dali::Gesture::State result;
30463
30464   arg1 = (Dali::Gesture *)jarg1;
30465   result = (Dali::Gesture::State) ((arg1)->state);
30466   jresult = (int)result;
30467   return jresult;
30468 }
30469
30470
30471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30472   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30473   unsigned int arg2 ;
30474
30475   arg1 = (Dali::Gesture *)jarg1;
30476   arg2 = (unsigned int)jarg2;
30477   if (arg1) (arg1)->time = arg2;
30478 }
30479
30480
30481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30482   unsigned int jresult ;
30483   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30484   unsigned int result;
30485
30486   arg1 = (Dali::Gesture *)jarg1;
30487   result = (unsigned int) ((arg1)->time);
30488   jresult = result;
30489   return jresult;
30490 }
30491
30492
30493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30494   void * jresult ;
30495   Dali::HoverEvent *result = 0 ;
30496
30497   {
30498     try {
30499       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30500     } catch (std::out_of_range& e) {
30501       {
30502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30503       };
30504     } catch (std::exception& e) {
30505       {
30506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30507       };
30508     } catch (Dali::DaliException e) {
30509       {
30510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30511       };
30512     } catch (...) {
30513       {
30514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30515       };
30516     }
30517   }
30518
30519   jresult = (void *)result;
30520   return jresult;
30521 }
30522
30523
30524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30525   void * jresult ;
30526   Dali::HoverEvent *arg1 = 0 ;
30527   Dali::HoverEvent *result = 0 ;
30528
30529   arg1 = (Dali::HoverEvent *)jarg1;
30530   if (!arg1) {
30531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30532     return 0;
30533   }
30534   {
30535     try {
30536       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30537     } catch (std::out_of_range& e) {
30538       {
30539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (std::exception& e) {
30542       {
30543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30544       };
30545     } catch (Dali::DaliException e) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30548       };
30549     } catch (...) {
30550       {
30551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30552       };
30553     }
30554   }
30555
30556   jresult = (void *)result;
30557   return jresult;
30558 }
30559
30560
30561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30562   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30563
30564   arg1 = (Dali::HoverEvent *)jarg1;
30565   {
30566     try {
30567       delete arg1;
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30583       };
30584     }
30585   }
30586
30587 }
30588
30589
30590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30591   void * jresult ;
30592   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30593   Dali::HoverEvent *arg2 = 0 ;
30594   Dali::HoverEvent *result = 0 ;
30595
30596   arg1 = (Dali::HoverEvent *)jarg1;
30597   arg2 = (Dali::HoverEvent *)jarg2;
30598   if (!arg2) {
30599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30600     return 0;
30601   }
30602   {
30603     try {
30604       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30612       };
30613     } catch (Dali::DaliException e) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30616       };
30617     } catch (...) {
30618       {
30619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30620       };
30621     }
30622   }
30623
30624   jresult = (void *)result;
30625   return jresult;
30626 }
30627
30628
30629 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30630   unsigned long jresult ;
30631   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30632   unsigned long result;
30633
30634   arg1 = (Dali::HoverEvent *)jarg1;
30635   {
30636     try {
30637       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30638     } catch (std::out_of_range& e) {
30639       {
30640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30641       };
30642     } catch (std::exception& e) {
30643       {
30644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30645       };
30646     } catch (Dali::DaliException e) {
30647       {
30648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30649       };
30650     } catch (...) {
30651       {
30652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30653       };
30654     }
30655   }
30656
30657   jresult = (unsigned long)result;
30658   return jresult;
30659 }
30660
30661
30662 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30663   unsigned long jresult ;
30664   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30665   std::size_t result;
30666
30667   arg1 = (Dali::HoverEvent *)jarg1;
30668   {
30669     try {
30670       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30671     } catch (std::out_of_range& e) {
30672       {
30673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30674       };
30675     } catch (std::exception& e) {
30676       {
30677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30678       };
30679     } catch (Dali::DaliException e) {
30680       {
30681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30682       };
30683     } catch (...) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30686       };
30687     }
30688   }
30689
30690   jresult = (unsigned long)result;
30691   return jresult;
30692 }
30693
30694
30695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30696   int jresult ;
30697   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30698   std::size_t arg2 ;
30699   int32_t result;
30700
30701   arg1 = (Dali::HoverEvent *)jarg1;
30702   arg2 = (std::size_t)jarg2;
30703   {
30704     try {
30705       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30706     } catch (std::out_of_range& e) {
30707       {
30708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30709       };
30710     } catch (std::exception& e) {
30711       {
30712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30713       };
30714     } catch (Dali::DaliException e) {
30715       {
30716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30717       };
30718     } catch (...) {
30719       {
30720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30721       };
30722     }
30723   }
30724
30725   jresult = result;
30726   return jresult;
30727 }
30728
30729
30730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30731   int jresult ;
30732   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30733   std::size_t arg2 ;
30734   Dali::PointState::Type result;
30735
30736   arg1 = (Dali::HoverEvent *)jarg1;
30737   arg2 = (std::size_t)jarg2;
30738   {
30739     try {
30740       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30741     } catch (std::out_of_range& e) {
30742       {
30743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30744       };
30745     } catch (std::exception& e) {
30746       {
30747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30748       };
30749     } catch (Dali::DaliException e) {
30750       {
30751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30752       };
30753     } catch (...) {
30754       {
30755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30756       };
30757     }
30758   }
30759
30760   jresult = (int)result;
30761   return jresult;
30762 }
30763
30764
30765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30766   void * jresult ;
30767   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30768   std::size_t arg2 ;
30769   Dali::Actor result;
30770
30771   arg1 = (Dali::HoverEvent *)jarg1;
30772   arg2 = (std::size_t)jarg2;
30773   {
30774     try {
30775       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30776     } catch (std::out_of_range& e) {
30777       {
30778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30779       };
30780     } catch (std::exception& e) {
30781       {
30782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30783       };
30784     } catch (Dali::DaliException e) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30787       };
30788     } catch (...) {
30789       {
30790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30791       };
30792     }
30793   }
30794
30795   jresult = new Dali::Actor((const Dali::Actor &)result);
30796   return jresult;
30797 }
30798
30799
30800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30801   void * jresult ;
30802   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30803   std::size_t arg2 ;
30804   Dali::Vector2 *result = 0 ;
30805
30806   arg1 = (Dali::HoverEvent *)jarg1;
30807   arg2 = (std::size_t)jarg2;
30808   {
30809     try {
30810       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30811     } catch (std::out_of_range& e) {
30812       {
30813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30814       };
30815     } catch (std::exception& e) {
30816       {
30817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30818       };
30819     } catch (Dali::DaliException e) {
30820       {
30821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30822       };
30823     } catch (...) {
30824       {
30825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30826       };
30827     }
30828   }
30829
30830   jresult = (void *)result;
30831   return jresult;
30832 }
30833
30834
30835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30836   void * jresult ;
30837   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30838   std::size_t arg2 ;
30839   Dali::Vector2 *result = 0 ;
30840
30841   arg1 = (Dali::HoverEvent *)jarg1;
30842   arg2 = (std::size_t)jarg2;
30843   {
30844     try {
30845       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30846     } catch (std::out_of_range& e) {
30847       {
30848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30849       };
30850     } catch (std::exception& e) {
30851       {
30852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30853       };
30854     } catch (Dali::DaliException e) {
30855       {
30856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30857       };
30858     } catch (...) {
30859       {
30860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30861       };
30862     }
30863   }
30864
30865   jresult = (void *)result;
30866   return jresult;
30867 }
30868
30869
30870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30871   void * jresult ;
30872   Dali::KeyEvent *result = 0 ;
30873
30874   {
30875     try {
30876       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30877     } catch (std::out_of_range& e) {
30878       {
30879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30880       };
30881     } catch (std::exception& e) {
30882       {
30883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30884       };
30885     } catch (Dali::DaliException e) {
30886       {
30887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30888       };
30889     } catch (...) {
30890       {
30891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30892       };
30893     }
30894   }
30895
30896   jresult = (void *)result;
30897   return jresult;
30898 }
30899
30900
30901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
30902   void * jresult ;
30903   Dali::KeyEvent *arg1 = 0 ;
30904   Dali::KeyEvent *result = 0 ;
30905
30906   arg1 = (Dali::KeyEvent *)jarg1;
30907   if (!arg1) {
30908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30909     return 0;
30910   }
30911   {
30912     try {
30913       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30914     } catch (std::out_of_range& e) {
30915       {
30916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (std::exception& e) {
30919       {
30920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30921       };
30922     } catch (Dali::DaliException e) {
30923       {
30924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30925       };
30926     } catch (...) {
30927       {
30928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30929       };
30930     }
30931   }
30932
30933   jresult = (void *)result;
30934   return jresult;
30935 }
30936
30937
30938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30939   void * jresult ;
30940   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30941   Dali::KeyEvent *arg2 = 0 ;
30942   Dali::KeyEvent *result = 0 ;
30943
30944   arg1 = (Dali::KeyEvent *)jarg1;
30945   arg2 = (Dali::KeyEvent *)jarg2;
30946   if (!arg2) {
30947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30948     return 0;
30949   }
30950   {
30951     try {
30952       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30953     } catch (std::out_of_range& e) {
30954       {
30955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30956       };
30957     } catch (std::exception& e) {
30958       {
30959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30960       };
30961     } catch (Dali::DaliException e) {
30962       {
30963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30964       };
30965     } catch (...) {
30966       {
30967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30968       };
30969     }
30970   }
30971
30972   jresult = (void *)result;
30973   return jresult;
30974 }
30975
30976
30977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30978   void * jresult ;
30979   std::string *arg1 = 0 ;
30980   std::string *arg2 = 0 ;
30981   int arg3 ;
30982   int arg4 ;
30983   unsigned long arg5 ;
30984   Dali::KeyEvent::State *arg6 = 0 ;
30985   Dali::KeyEvent::State temp6 ;
30986   Dali::KeyEvent result;
30987
30988   if (!jarg1) {
30989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30990     return 0;
30991   }
30992   std::string arg1_str(jarg1);
30993   arg1 = &arg1_str;
30994   if (!jarg2) {
30995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30996     return 0;
30997   }
30998   std::string arg2_str(jarg2);
30999   arg2 = &arg2_str;
31000   arg3 = (int)jarg3;
31001   arg4 = (int)jarg4;
31002   arg5 = (unsigned long)jarg5;
31003   temp6 = (Dali::KeyEvent::State)jarg6;
31004   arg6 = &temp6;
31005   {
31006     try {
31007       result = DevelKeyEvent::New((std::string const &)*arg1, "", (std::string const &)*arg2, arg3, arg4, arg5, (Dali::KeyEvent::State const &)*arg6, "", "", Device::Class::NONE, Device::Subclass::NONE);
31008     } catch (std::out_of_range& e) {
31009       {
31010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31011       };
31012     } catch (std::exception& e) {
31013       {
31014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31015       };
31016     } catch (Dali::DaliException e) {
31017       {
31018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31019       };
31020     } catch (...) {
31021       {
31022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31023       };
31024     }
31025   }
31026
31027   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
31028
31029   //argout typemap for const std::string&
31030
31031
31032   //argout typemap for const std::string&
31033
31034   return jresult;
31035 }
31036
31037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31038   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31039
31040   arg1 = (Dali::KeyEvent *)jarg1;
31041   {
31042     try {
31043       delete arg1;
31044     } catch (std::out_of_range& e) {
31045       {
31046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31047       };
31048     } catch (std::exception& e) {
31049       {
31050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31051       };
31052     } catch (Dali::DaliException e) {
31053       {
31054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31055       };
31056     } catch (...) {
31057       {
31058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31059       };
31060     }
31061   }
31062
31063 }
31064
31065
31066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31067   unsigned int jresult ;
31068   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31069   bool result;
31070
31071   arg1 = (Dali::KeyEvent *)jarg1;
31072   {
31073     try {
31074       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31075     } catch (std::out_of_range& e) {
31076       {
31077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31078       };
31079     } catch (std::exception& e) {
31080       {
31081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31082       };
31083     } catch (Dali::DaliException e) {
31084       {
31085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31086       };
31087     } catch (...) {
31088       {
31089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31090       };
31091     }
31092   }
31093
31094   jresult = result;
31095   return jresult;
31096 }
31097
31098
31099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31100   unsigned int jresult ;
31101   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31102   bool result;
31103
31104   arg1 = (Dali::KeyEvent *)jarg1;
31105   {
31106     try {
31107       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31108     } catch (std::out_of_range& e) {
31109       {
31110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31111       };
31112     } catch (std::exception& e) {
31113       {
31114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (Dali::DaliException e) {
31117       {
31118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126
31127   jresult = result;
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31133   unsigned int jresult ;
31134   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31135   bool result;
31136
31137   arg1 = (Dali::KeyEvent *)jarg1;
31138   {
31139     try {
31140       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31148       };
31149     } catch (Dali::DaliException e) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31152       };
31153     } catch (...) {
31154       {
31155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31156       };
31157     }
31158   }
31159
31160   jresult = result;
31161   return jresult;
31162 }
31163
31164
31165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31166   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31167   std::string *arg2 = 0 ;
31168
31169   Dali::KeyEvent arg1 = *argp1;
31170   if (!jarg2) {
31171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31172     return ;
31173   }
31174   std::string arg2_str(jarg2);
31175   arg2 = &arg2_str;
31176
31177   {
31178     try {
31179       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
31180     } catch (std::out_of_range& e) {
31181       {
31182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31183       };
31184     } catch (std::exception& e) {
31185       {
31186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31187       };
31188     } catch (Dali::DaliException e) {
31189       {
31190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31191       };
31192     } catch (...) {
31193       {
31194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31195       };
31196     }
31197   }
31198 }
31199
31200
31201 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31202   char * jresult ;
31203
31204   if( jarg1 == NULL )
31205   {
31206     jresult = SWIG_csharp_string_callback( "" );
31207   }
31208   else
31209   {
31210     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31211     std::string *result = 0;
31212
31213     arg1 = ( Dali::KeyEvent * )jarg1;
31214     {
31215       try {
31216         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
31217         result = (std::string *) &str;
31218       } catch (std::out_of_range& e) {
31219         {
31220           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31221         };
31222       } catch (std::exception& e) {
31223         {
31224           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31225         };
31226       } catch (Dali::DaliException e) {
31227         {
31228           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31229         };
31230       } catch (...) {
31231         {
31232           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31233         };
31234       }
31235     }
31236
31237     jresult = SWIG_csharp_string_callback(result->c_str());
31238   }
31239
31240   return jresult;
31241 }
31242
31243
31244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31245   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31246   std::string *arg2 = 0 ;
31247
31248   Dali::KeyEvent arg1 = *argp1;
31249   if (!jarg2) {
31250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31251     return ;
31252   }
31253   std::string arg2_str(jarg2);
31254   arg2 = &arg2_str;
31255
31256   {
31257     try {
31258       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
31259     } catch (std::out_of_range& e) {
31260       {
31261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31262       };
31263     } catch (std::exception& e) {
31264       {
31265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31266       };
31267     } catch (Dali::DaliException e) {
31268       {
31269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31270       };
31271     } catch (...) {
31272       {
31273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31274       };
31275     }
31276   }
31277 }
31278
31279
31280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31281   char * jresult ;
31282
31283   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31284   std::string *result = 0;
31285
31286   arg1 = ( Dali::KeyEvent * )jarg1;
31287   {
31288     try {
31289       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
31290       result = (std::string *) &str;
31291     } catch (std::out_of_range& e) {
31292       {
31293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31294       };
31295     } catch (std::exception& e) {
31296       {
31297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31298       };
31299     } catch (Dali::DaliException e) {
31300       {
31301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31302       };
31303     } catch (...) {
31304       {
31305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31306       };
31307     }
31308
31309     jresult = SWIG_csharp_string_callback(result->c_str());
31310   }
31311
31312   return jresult;
31313 }
31314
31315
31316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31317   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31318   int arg2 ;
31319
31320   Dali::KeyEvent arg1 = *argp1;
31321   arg2 = (int)jarg2;
31322   {
31323     try {
31324       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
31325     } catch (std::out_of_range& e) {
31326       {
31327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31328       };
31329     } catch (std::exception& e) {
31330       {
31331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31332       };
31333     } catch (Dali::DaliException e) {
31334       {
31335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31336       };
31337     } catch (...) {
31338       {
31339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31340       };
31341     }
31342   }
31343 }
31344
31345
31346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31347   int jresult ;
31348   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31349   int result;
31350
31351   arg1 = (Dali::KeyEvent *)jarg1;
31352   {
31353     try {
31354       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
31355     } catch (std::out_of_range& e) {
31356       {
31357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31358       };
31359     } catch (std::exception& e) {
31360       {
31361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (Dali::DaliException e) {
31364       {
31365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31366       };
31367     } catch (...) {
31368       {
31369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31370       };
31371     }
31372   }
31373
31374   jresult = result;
31375   return jresult;
31376 }
31377
31378
31379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31380   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31381   int arg2 ;
31382
31383   Dali::KeyEvent arg1 = *argp1;
31384   arg2 = (int)jarg2;
31385   {
31386     try {
31387       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31395       };
31396     } catch (Dali::DaliException e) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31399       };
31400     } catch (...) {
31401       {
31402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31403       };
31404     }
31405   }
31406 }
31407
31408
31409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31410   int jresult ;
31411   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412   int result;
31413
31414   arg1 = (Dali::KeyEvent *)jarg1;
31415   {
31416     try {
31417       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
31418     } catch (std::out_of_range& e) {
31419       {
31420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31421       };
31422     } catch (std::exception& e) {
31423       {
31424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31425       };
31426     } catch (Dali::DaliException e) {
31427       {
31428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31429       };
31430     } catch (...) {
31431       {
31432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31433       };
31434     }
31435   }
31436
31437   jresult = result;
31438   return jresult;
31439 }
31440
31441
31442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31443   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
31444   unsigned long arg2 ;
31445
31446   Dali::KeyEvent arg1 = *argp1;
31447   arg2 = (int)jarg2;
31448   {
31449     try {
31450       Dali::DevelKeyEvent::SetTime(arg1, arg2);
31451     } catch (std::out_of_range& e) {
31452       {
31453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31454       };
31455     } catch (std::exception& e) {
31456       {
31457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31458       };
31459     } catch (Dali::DaliException e) {
31460       {
31461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31462       };
31463     } catch (...) {
31464       {
31465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31466       };
31467     }
31468   }
31469 }
31470
31471
31472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31473   unsigned long jresult ;
31474   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31475   unsigned long result;
31476
31477   arg1 = (Dali::KeyEvent *)jarg1;
31478   {
31479     try {
31480       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
31481     } catch (std::out_of_range& e) {
31482       {
31483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31484       };
31485     } catch (std::exception& e) {
31486       {
31487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31488       };
31489     } catch (Dali::DaliException e) {
31490       {
31491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31492       };
31493     } catch (...) {
31494       {
31495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31496       };
31497     }
31498   }
31499
31500   jresult = result;
31501   return jresult;
31502 }
31503
31504
31505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31506   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
31507   Dali::KeyEvent::State arg2;
31508
31509   Dali::KeyEvent arg1 = *argp1;
31510   arg2 = (Dali::KeyEvent::State)jarg2;
31511   {
31512     try {
31513       Dali::DevelKeyEvent::SetState(arg1, arg2);
31514     } catch (std::out_of_range& e) {
31515       {
31516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31517       };
31518     } catch (std::exception& e) {
31519       {
31520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31521       };
31522     } catch (Dali::DaliException e) {
31523       {
31524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31525       };
31526     } catch (...) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31529       };
31530     }
31531   }
31532 }
31533
31534
31535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31536   int jresult ;
31537   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31538   Dali::KeyEvent::State result;
31539
31540   arg1 = (Dali::KeyEvent *)jarg1;
31541   {
31542     try {
31543       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
31544     } catch (std::out_of_range& e) {
31545       {
31546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31547       };
31548     } catch (std::exception& e) {
31549       {
31550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31551       };
31552     } catch (Dali::DaliException e) {
31553       {
31554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31555       };
31556     } catch (...) {
31557       {
31558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31559       };
31560     }
31561   }
31562
31563   jresult = (int)result;
31564   return jresult;
31565
31566 }
31567
31568 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31569   char * jresult ;
31570
31571   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31572   std::string *result = 0;
31573
31574   arg1 = ( Dali::KeyEvent * )jarg1;
31575   {
31576     try {
31577       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
31578       result = (std::string *) &str;
31579     } catch (std::out_of_range& e) {
31580       {
31581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31582       };
31583     } catch (std::exception& e) {
31584       {
31585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31586       };
31587     } catch (Dali::DaliException e) {
31588       {
31589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31590       };
31591     } catch (...) {
31592       {
31593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31594       };
31595     }
31596
31597   }
31598
31599   jresult = SWIG_csharp_string_callback(result->c_str());
31600   return jresult;
31601 }
31602
31603
31604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31605   void * jresult ;
31606   Dali::LongPressGestureDetector *result = 0 ;
31607
31608   {
31609     try {
31610       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31611     } catch (std::out_of_range& e) {
31612       {
31613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31614       };
31615     } catch (std::exception& e) {
31616       {
31617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31618       };
31619     } catch (Dali::DaliException e) {
31620       {
31621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31622       };
31623     } catch (...) {
31624       {
31625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31626       };
31627     }
31628   }
31629
31630   jresult = (void *)result;
31631   return jresult;
31632 }
31633
31634
31635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31636   void * jresult ;
31637   Dali::LongPressGestureDetector result;
31638
31639   {
31640     try {
31641       result = Dali::LongPressGestureDetector::New();
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31649       };
31650     } catch (Dali::DaliException e) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31653       };
31654     } catch (...) {
31655       {
31656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31657       };
31658     }
31659   }
31660
31661   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31662   return jresult;
31663 }
31664
31665
31666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31667   void * jresult ;
31668   unsigned int arg1 ;
31669   Dali::LongPressGestureDetector result;
31670
31671   arg1 = (unsigned int)jarg1;
31672   {
31673     try {
31674       result = Dali::LongPressGestureDetector::New(arg1);
31675     } catch (std::out_of_range& e) {
31676       {
31677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31678       };
31679     } catch (std::exception& e) {
31680       {
31681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31682       };
31683     } catch (Dali::DaliException e) {
31684       {
31685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31690       };
31691     }
31692   }
31693
31694   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31695   return jresult;
31696 }
31697
31698
31699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31700   void * jresult ;
31701   unsigned int arg1 ;
31702   unsigned int arg2 ;
31703   Dali::LongPressGestureDetector result;
31704
31705   arg1 = (unsigned int)jarg1;
31706   arg2 = (unsigned int)jarg2;
31707   {
31708     try {
31709       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31710     } catch (std::out_of_range& e) {
31711       {
31712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (std::exception& e) {
31715       {
31716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31717       };
31718     } catch (Dali::DaliException e) {
31719       {
31720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31721       };
31722     } catch (...) {
31723       {
31724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31725       };
31726     }
31727   }
31728
31729   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31730   return jresult;
31731 }
31732
31733
31734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31735   void * jresult ;
31736   Dali::BaseHandle arg1 ;
31737   Dali::BaseHandle *argp1 ;
31738   Dali::LongPressGestureDetector result;
31739
31740   argp1 = (Dali::BaseHandle *)jarg1;
31741   if (!argp1) {
31742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31743     return 0;
31744   }
31745   arg1 = *argp1;
31746   {
31747     try {
31748       result = Dali::LongPressGestureDetector::DownCast(arg1);
31749     } catch (std::out_of_range& e) {
31750       {
31751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31752       };
31753     } catch (std::exception& e) {
31754       {
31755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31756       };
31757     } catch (Dali::DaliException e) {
31758       {
31759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31760       };
31761     } catch (...) {
31762       {
31763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31764       };
31765     }
31766   }
31767
31768   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31769   return jresult;
31770 }
31771
31772
31773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31774   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31775
31776   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31777   {
31778     try {
31779       delete arg1;
31780     } catch (std::out_of_range& e) {
31781       {
31782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31783       };
31784     } catch (std::exception& e) {
31785       {
31786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31787       };
31788     } catch (Dali::DaliException e) {
31789       {
31790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31791       };
31792     } catch (...) {
31793       {
31794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31795       };
31796     }
31797   }
31798
31799 }
31800
31801
31802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31803   void * jresult ;
31804   Dali::LongPressGestureDetector *arg1 = 0 ;
31805   Dali::LongPressGestureDetector *result = 0 ;
31806
31807   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31808   if (!arg1) {
31809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31810     return 0;
31811   }
31812   {
31813     try {
31814       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31815     } catch (std::out_of_range& e) {
31816       {
31817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31818       };
31819     } catch (std::exception& e) {
31820       {
31821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31822       };
31823     } catch (Dali::DaliException e) {
31824       {
31825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31826       };
31827     } catch (...) {
31828       {
31829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31830       };
31831     }
31832   }
31833
31834   jresult = (void *)result;
31835   return jresult;
31836 }
31837
31838
31839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31840   void * jresult ;
31841   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31842   Dali::LongPressGestureDetector *arg2 = 0 ;
31843   Dali::LongPressGestureDetector *result = 0 ;
31844
31845   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31846   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31847   if (!arg2) {
31848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31849     return 0;
31850   }
31851   {
31852     try {
31853       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31854     } catch (std::out_of_range& e) {
31855       {
31856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31857       };
31858     } catch (std::exception& e) {
31859       {
31860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31861       };
31862     } catch (Dali::DaliException e) {
31863       {
31864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31865       };
31866     } catch (...) {
31867       {
31868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31869       };
31870     }
31871   }
31872
31873   jresult = (void *)result;
31874   return jresult;
31875 }
31876
31877
31878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31879   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31880   unsigned int arg2 ;
31881
31882   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31883   arg2 = (unsigned int)jarg2;
31884   {
31885     try {
31886       (arg1)->SetTouchesRequired(arg2);
31887     } catch (std::out_of_range& e) {
31888       {
31889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31890       };
31891     } catch (std::exception& e) {
31892       {
31893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31894       };
31895     } catch (Dali::DaliException e) {
31896       {
31897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31898       };
31899     } catch (...) {
31900       {
31901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31902       };
31903     }
31904   }
31905
31906 }
31907
31908
31909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31910   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31911   unsigned int arg2 ;
31912   unsigned int arg3 ;
31913
31914   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31915   arg2 = (unsigned int)jarg2;
31916   arg3 = (unsigned int)jarg3;
31917   {
31918     try {
31919       (arg1)->SetTouchesRequired(arg2,arg3);
31920     } catch (std::out_of_range& e) {
31921       {
31922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31923       };
31924     } catch (std::exception& e) {
31925       {
31926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31927       };
31928     } catch (Dali::DaliException e) {
31929       {
31930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31931       };
31932     } catch (...) {
31933       {
31934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31935       };
31936     }
31937   }
31938
31939 }
31940
31941
31942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31943   unsigned int jresult ;
31944   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31945   unsigned int result;
31946
31947   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31948   {
31949     try {
31950       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31951     } catch (std::out_of_range& e) {
31952       {
31953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31954       };
31955     } catch (std::exception& e) {
31956       {
31957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31958       };
31959     } catch (Dali::DaliException e) {
31960       {
31961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31962       };
31963     } catch (...) {
31964       {
31965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31966       };
31967     }
31968   }
31969
31970   jresult = result;
31971   return jresult;
31972 }
31973
31974
31975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31976   unsigned int jresult ;
31977   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31978   unsigned int result;
31979
31980   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31981   {
31982     try {
31983       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31984     } catch (std::out_of_range& e) {
31985       {
31986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31987       };
31988     } catch (std::exception& e) {
31989       {
31990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31991       };
31992     } catch (Dali::DaliException e) {
31993       {
31994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31995       };
31996     } catch (...) {
31997       {
31998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31999       };
32000     }
32001   }
32002
32003   jresult = result;
32004   return jresult;
32005 }
32006
32007
32008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32009   void * jresult ;
32010   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32011   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32012
32013   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32014   {
32015     try {
32016       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32017     } catch (std::out_of_range& e) {
32018       {
32019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32020       };
32021     } catch (std::exception& e) {
32022       {
32023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32024       };
32025     } catch (Dali::DaliException e) {
32026       {
32027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32028       };
32029     } catch (...) {
32030       {
32031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32032       };
32033     }
32034   }
32035
32036   jresult = (void *)result;
32037   return jresult;
32038 }
32039
32040
32041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32042   void * jresult ;
32043   Dali::Gesture::State arg1 ;
32044   Dali::LongPressGesture *result = 0 ;
32045
32046   arg1 = (Dali::Gesture::State)jarg1;
32047   {
32048     try {
32049       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32050     } catch (std::out_of_range& e) {
32051       {
32052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32053       };
32054     } catch (std::exception& e) {
32055       {
32056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32057       };
32058     } catch (Dali::DaliException e) {
32059       {
32060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32061       };
32062     } catch (...) {
32063       {
32064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32065       };
32066     }
32067   }
32068
32069   jresult = (void *)result;
32070   return jresult;
32071 }
32072
32073
32074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32075   void * jresult ;
32076   Dali::LongPressGesture *arg1 = 0 ;
32077   Dali::LongPressGesture *result = 0 ;
32078
32079   arg1 = (Dali::LongPressGesture *)jarg1;
32080   if (!arg1) {
32081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32082     return 0;
32083   }
32084   {
32085     try {
32086       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32087     } catch (std::out_of_range& e) {
32088       {
32089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32090       };
32091     } catch (std::exception& e) {
32092       {
32093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32094       };
32095     } catch (Dali::DaliException e) {
32096       {
32097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32098       };
32099     } catch (...) {
32100       {
32101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32102       };
32103     }
32104   }
32105
32106   jresult = (void *)result;
32107   return jresult;
32108 }
32109
32110
32111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32112   void * jresult ;
32113   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32114   Dali::LongPressGesture *arg2 = 0 ;
32115   Dali::LongPressGesture *result = 0 ;
32116
32117   arg1 = (Dali::LongPressGesture *)jarg1;
32118   arg2 = (Dali::LongPressGesture *)jarg2;
32119   if (!arg2) {
32120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32121     return 0;
32122   }
32123   {
32124     try {
32125       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32126     } catch (std::out_of_range& e) {
32127       {
32128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32129       };
32130     } catch (std::exception& e) {
32131       {
32132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32133       };
32134     } catch (Dali::DaliException e) {
32135       {
32136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32137       };
32138     } catch (...) {
32139       {
32140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32141       };
32142     }
32143   }
32144
32145   jresult = (void *)result;
32146   return jresult;
32147 }
32148
32149
32150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32151   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32152
32153   arg1 = (Dali::LongPressGesture *)jarg1;
32154   {
32155     try {
32156       delete arg1;
32157     } catch (std::out_of_range& e) {
32158       {
32159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32160       };
32161     } catch (std::exception& e) {
32162       {
32163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32164       };
32165     } catch (Dali::DaliException e) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32168       };
32169     } catch (...) {
32170       {
32171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32172       };
32173     }
32174   }
32175
32176 }
32177
32178
32179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32180   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32181   unsigned int arg2 ;
32182
32183   arg1 = (Dali::LongPressGesture *)jarg1;
32184   arg2 = (unsigned int)jarg2;
32185   if (arg1) (arg1)->numberOfTouches = arg2;
32186 }
32187
32188
32189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32190   unsigned int jresult ;
32191   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32192   unsigned int result;
32193
32194   arg1 = (Dali::LongPressGesture *)jarg1;
32195   result = (unsigned int) ((arg1)->numberOfTouches);
32196   jresult = result;
32197   return jresult;
32198 }
32199
32200
32201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32202   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32203   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32204
32205   arg1 = (Dali::LongPressGesture *)jarg1;
32206   arg2 = (Dali::Vector2 *)jarg2;
32207   if (arg1) (arg1)->screenPoint = *arg2;
32208 }
32209
32210
32211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32212   void * jresult ;
32213   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32214   Dali::Vector2 *result = 0 ;
32215
32216   arg1 = (Dali::LongPressGesture *)jarg1;
32217   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32218   jresult = (void *)result;
32219   return jresult;
32220 }
32221
32222
32223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32224   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32225   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32226
32227   arg1 = (Dali::LongPressGesture *)jarg1;
32228   arg2 = (Dali::Vector2 *)jarg2;
32229   if (arg1) (arg1)->localPoint = *arg2;
32230 }
32231
32232
32233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32234   void * jresult ;
32235   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32236   Dali::Vector2 *result = 0 ;
32237
32238   arg1 = (Dali::LongPressGesture *)jarg1;
32239   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32240   jresult = (void *)result;
32241   return jresult;
32242 }
32243
32244
32245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32246   void * jresult ;
32247   Dali::WheelEvent *result = 0 ;
32248
32249   {
32250     try {
32251       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32252     } catch (std::out_of_range& e) {
32253       {
32254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (std::exception& e) {
32257       {
32258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32259       };
32260     } catch (Dali::DaliException e) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32263       };
32264     } catch (...) {
32265       {
32266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32267       };
32268     }
32269   }
32270
32271   jresult = (void *)result;
32272   return jresult;
32273 }
32274
32275
32276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
32277   void * jresult ;
32278   Dali::WheelEvent *arg1 = 0 ;
32279   Dali::WheelEvent *result = 0 ;
32280
32281   arg1 = (Dali::WheelEvent *)jarg1;
32282   if (!arg1) {
32283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32284     return 0;
32285   }
32286   {
32287     try {
32288       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
32289     } catch (std::out_of_range& e) {
32290       {
32291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32292       };
32293     } catch (std::exception& e) {
32294       {
32295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32296       };
32297     } catch (Dali::DaliException e) {
32298       {
32299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32300       };
32301     } catch (...) {
32302       {
32303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32304       };
32305     }
32306   }
32307
32308   jresult = (void *)result;
32309   return jresult;
32310 }
32311
32312
32313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
32314   void * jresult ;
32315   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32316   Dali::WheelEvent *arg2 = 0 ;
32317   Dali::WheelEvent *result = 0 ;
32318
32319   arg1 = (Dali::WheelEvent *)jarg1;
32320   arg2 = (Dali::WheelEvent *)jarg2;
32321   if (!arg2) {
32322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32323     return 0;
32324   }
32325   {
32326     try {
32327       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
32328     } catch (std::out_of_range& e) {
32329       {
32330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32331       };
32332     } catch (std::exception& e) {
32333       {
32334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32335       };
32336     } catch (Dali::DaliException e) {
32337       {
32338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32339       };
32340     } catch (...) {
32341       {
32342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32343       };
32344     }
32345   }
32346
32347   jresult = (void *)result;
32348   return jresult;
32349 }
32350
32351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32352   void * jresult ;
32353   Dali::WheelEvent::Type arg1 ;
32354   int arg2 ;
32355   unsigned int arg3 ;
32356   Dali::Vector2 arg4 ;
32357   int arg5 ;
32358   unsigned int arg6 ;
32359   Dali::Vector2 *argp4 ;
32360   Dali::WheelEvent result;
32361
32362   arg1 = (Dali::WheelEvent::Type)jarg1;
32363   arg2 = (int)jarg2;
32364   arg3 = (unsigned int)jarg3;
32365   argp4 = (Dali::Vector2 *)jarg4;
32366   if (!argp4) {
32367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32368     return 0;
32369   }
32370   arg4 = *argp4;
32371   arg5 = (int)jarg5;
32372   arg6 = (unsigned int)jarg6;
32373   {
32374     try {
32375       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
32376     } catch (std::out_of_range& e) {
32377       {
32378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32379       };
32380     } catch (std::exception& e) {
32381       {
32382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32383       };
32384     } catch (Dali::DaliException e) {
32385       {
32386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32387       };
32388     } catch (...) {
32389       {
32390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32391       };
32392     }
32393   }
32394
32395   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
32396   return jresult;
32397 }
32398
32399
32400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32401   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32402
32403   arg1 = (Dali::WheelEvent *)jarg1;
32404   {
32405     try {
32406       delete arg1;
32407     } catch (std::out_of_range& e) {
32408       {
32409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32410       };
32411     } catch (std::exception& e) {
32412       {
32413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32414       };
32415     } catch (Dali::DaliException e) {
32416       {
32417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32418       };
32419     } catch (...) {
32420       {
32421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32422       };
32423     }
32424   }
32425
32426 }
32427
32428
32429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32430   unsigned int jresult ;
32431   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32432   bool result;
32433
32434   arg1 = (Dali::WheelEvent *)jarg1;
32435   {
32436     try {
32437       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32438     } catch (std::out_of_range& e) {
32439       {
32440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32441       };
32442     } catch (std::exception& e) {
32443       {
32444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32445       };
32446     } catch (Dali::DaliException e) {
32447       {
32448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32449       };
32450     } catch (...) {
32451       {
32452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32453       };
32454     }
32455   }
32456
32457   jresult = result;
32458   return jresult;
32459 }
32460
32461
32462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32463   unsigned int jresult ;
32464   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32465   bool result;
32466
32467   arg1 = (Dali::WheelEvent *)jarg1;
32468   {
32469     try {
32470       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32471     } catch (std::out_of_range& e) {
32472       {
32473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32474       };
32475     } catch (std::exception& e) {
32476       {
32477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32478       };
32479     } catch (Dali::DaliException e) {
32480       {
32481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32482       };
32483     } catch (...) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32486       };
32487     }
32488   }
32489
32490   jresult = result;
32491   return jresult;
32492 }
32493
32494
32495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32496   unsigned int jresult ;
32497   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32498   bool result;
32499
32500   arg1 = (Dali::WheelEvent *)jarg1;
32501   {
32502     try {
32503       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32504     } catch (std::out_of_range& e) {
32505       {
32506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32507       };
32508     } catch (std::exception& e) {
32509       {
32510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32511       };
32512     } catch (Dali::DaliException e) {
32513       {
32514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32515       };
32516     } catch (...) {
32517       {
32518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32519       };
32520     }
32521   }
32522
32523   jresult = result;
32524   return jresult;
32525 }
32526
32527
32528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32529   int jresult ;
32530   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32531   Dali::WheelEvent::Type result;
32532
32533   arg1 = (Dali::WheelEvent *)jarg1;
32534   {
32535     try {
32536       result = ((Dali::WheelEvent const *)arg1)->GetType();
32537     } catch (std::out_of_range& e) {
32538       {
32539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32540       };
32541     } catch (std::exception& e) {
32542       {
32543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32544       };
32545     } catch (Dali::DaliException e) {
32546       {
32547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32548       };
32549     } catch (...) {
32550       {
32551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32552       };
32553     }
32554   }
32555
32556   jresult = (int)result;
32557   return jresult;
32558 }
32559
32560
32561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32562   int jresult ;
32563   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32564   int result;
32565
32566   arg1 = (Dali::WheelEvent *)jarg1;
32567   {
32568     try {
32569       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
32570     } catch (std::out_of_range& e) {
32571       {
32572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32573       };
32574     } catch (std::exception& e) {
32575       {
32576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32577       };
32578     } catch (Dali::DaliException e) {
32579       {
32580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32581       };
32582     } catch (...) {
32583       {
32584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32585       };
32586     }
32587   }
32588
32589   jresult = result;
32590   return jresult;
32591 }
32592
32593
32594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32595   unsigned int jresult ;
32596   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32597   unsigned int result;
32598
32599   arg1 = (Dali::WheelEvent *)jarg1;
32600   {
32601     try {
32602       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
32603     } catch (std::out_of_range& e) {
32604       {
32605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32606       };
32607     } catch (std::exception& e) {
32608       {
32609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32610       };
32611     } catch (Dali::DaliException e) {
32612       {
32613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32614       };
32615     } catch (...) {
32616       {
32617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32618       };
32619     }
32620   }
32621
32622   jresult = result;
32623   return jresult;
32624 }
32625
32626
32627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32628   void * jresult ;
32629   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32630   Dali::Vector2 *result = 0 ;
32631
32632   arg1 = (Dali::WheelEvent *)jarg1;
32633   {
32634     try {
32635       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
32636     } catch (std::out_of_range& e) {
32637       {
32638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32639       };
32640     } catch (std::exception& e) {
32641       {
32642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32643       };
32644     } catch (Dali::DaliException e) {
32645       {
32646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32647       };
32648     } catch (...) {
32649       {
32650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32651       };
32652     }
32653   }
32654
32655   jresult = (void *)result;
32656   return jresult;
32657 }
32658
32659
32660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
32661   int jresult ;
32662   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32663   int result;
32664
32665   arg1 = (Dali::WheelEvent *)jarg1;
32666   {
32667     try {
32668       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
32669     } catch (std::out_of_range& e) {
32670       {
32671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32672       };
32673     } catch (std::exception& e) {
32674       {
32675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32676       };
32677     } catch (Dali::DaliException e) {
32678       {
32679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32680       };
32681     } catch (...) {
32682       {
32683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32684       };
32685     }
32686   }
32687
32688   jresult = result;
32689   return jresult;
32690 }
32691
32692
32693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32694   unsigned int jresult ;
32695   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32696   unsigned int result;
32697
32698   arg1 = (Dali::WheelEvent *)jarg1;
32699   {
32700     try {
32701       result = ((Dali::WheelEvent const *)arg1)->GetTime();
32702     } catch (std::out_of_range& e) {
32703       {
32704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32705       };
32706     } catch (std::exception& e) {
32707       {
32708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32709       };
32710     } catch (Dali::DaliException e) {
32711       {
32712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32713       };
32714     } catch (...) {
32715       {
32716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32717       };
32718     }
32719   }
32720
32721   jresult = result;
32722   return jresult;
32723 }
32724
32725 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32726   char * jresult ;
32727   Dali::KeyEvent *arg1 = 0 ;
32728   std::string result;
32729
32730   arg1 = (Dali::KeyEvent *)jarg1;
32731   if (!arg1) {
32732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32733     return 0;
32734   }
32735   {
32736     try {
32737       result = arg1->GetDeviceName();
32738     } catch (std::out_of_range& e) {
32739       {
32740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32741       };
32742     } catch (std::exception& e) {
32743       {
32744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32745       };
32746     } catch (Dali::DaliException e) {
32747       {
32748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32749       };
32750     } catch (...) {
32751       {
32752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32753       };
32754     }
32755   }
32756
32757   jresult = SWIG_csharp_string_callback((&result)->c_str());
32758   return jresult;
32759 }
32760
32761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32762   int jresult ;
32763   Dali::KeyEvent *arg1 = 0 ;
32764   Dali::Device::Class::Type result;
32765
32766   arg1 = (Dali::KeyEvent *)jarg1;
32767   if (!arg1) {
32768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32769     return 0;
32770   }
32771   {
32772     try {
32773       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32774     } catch (std::out_of_range& e) {
32775       {
32776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32777       };
32778     } catch (std::exception& e) {
32779       {
32780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32781       };
32782     } catch (Dali::DaliException e) {
32783       {
32784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32785       };
32786     } catch (...) {
32787       {
32788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32789       };
32790     }
32791   }
32792
32793   jresult = (int)result;
32794   return jresult;
32795 }
32796
32797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32798   int jresult ;
32799   Dali::KeyEvent *arg1 = 0 ;
32800   Dali::Device::Subclass::Type result;
32801
32802   arg1 = (Dali::KeyEvent *)jarg1;
32803   if (!arg1) {
32804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32805     return 0;
32806   }
32807   {
32808     try {
32809       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32810     } catch (std::out_of_range& e) {
32811       {
32812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32813       };
32814     } catch (std::exception& e) {
32815       {
32816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32817       };
32818     } catch (Dali::DaliException e) {
32819       {
32820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32821       };
32822     } catch (...) {
32823       {
32824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32825       };
32826     }
32827   }
32828
32829   jresult = (int)result;
32830   return jresult;
32831 }
32832
32833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32834   Dali::Actor arg1 ;
32835   Dali::Actor *argp1 ;
32836
32837   argp1 = (Dali::Actor *)jarg1;
32838   if (!argp1) {
32839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32840     return ;
32841   }
32842   arg1 = *argp1;
32843   {
32844     try {
32845       arg1.Raise();
32846     } catch (std::out_of_range& e) {
32847       {
32848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32849       };
32850     } catch (std::exception& e) {
32851       {
32852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32853       };
32854     } catch (Dali::DaliException e) {
32855       {
32856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32857       };
32858     } catch (...) {
32859       {
32860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32861       };
32862     }
32863   }
32864
32865 }
32866
32867
32868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32869   Dali::Actor arg1 ;
32870   Dali::Actor *argp1 ;
32871
32872   argp1 = (Dali::Actor *)jarg1;
32873   if (!argp1) {
32874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32875     return ;
32876   }
32877   arg1 = *argp1;
32878   {
32879     try {
32880       arg1.Lower();
32881     } catch (std::out_of_range& e) {
32882       {
32883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32884       };
32885     } catch (std::exception& e) {
32886       {
32887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32888       };
32889     } catch (Dali::DaliException e) {
32890       {
32891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32892       };
32893     } catch (...) {
32894       {
32895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32896       };
32897     }
32898   }
32899
32900 }
32901
32902
32903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32904   Dali::Actor arg1 ;
32905   Dali::Actor *argp1 ;
32906
32907   argp1 = (Dali::Actor *)jarg1;
32908   if (!argp1) {
32909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32910     return ;
32911   }
32912   arg1 = *argp1;
32913   {
32914     try {
32915       arg1.RaiseToTop();
32916     } catch (std::out_of_range& e) {
32917       {
32918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32919       };
32920     } catch (std::exception& e) {
32921       {
32922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32923       };
32924     } catch (Dali::DaliException e) {
32925       {
32926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32927       };
32928     } catch (...) {
32929       {
32930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32931       };
32932     }
32933   }
32934
32935 }
32936
32937
32938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32939   Dali::Actor arg1 ;
32940   Dali::Actor *argp1 ;
32941
32942   argp1 = (Dali::Actor *)jarg1;
32943   if (!argp1) {
32944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32945     return ;
32946   }
32947   arg1 = *argp1;
32948   {
32949     try {
32950       arg1.LowerToBottom();
32951     } catch (std::out_of_range& e) {
32952       {
32953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32954       };
32955     } catch (std::exception& e) {
32956       {
32957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32958       };
32959     } catch (Dali::DaliException e) {
32960       {
32961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32962       };
32963     } catch (...) {
32964       {
32965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32966       };
32967     }
32968   }
32969
32970 }
32971
32972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32973   Dali::Actor arg1 ;
32974   Dali::Actor arg2 ;
32975   Dali::Actor *argp1 ;
32976   Dali::Actor *argp2 ;
32977
32978   argp1 = (Dali::Actor *)jarg1;
32979   if (!argp1) {
32980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32981     return ;
32982   }
32983   arg1 = *argp1;
32984   argp2 = (Dali::Actor *)jarg2;
32985   if (!argp2) {
32986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32987     return ;
32988   }
32989   arg2 = *argp2;
32990   {
32991     try {
32992       arg1.RaiseAbove(arg2);
32993     } catch (std::out_of_range& e) {
32994       {
32995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32996       };
32997     } catch (std::exception& e) {
32998       {
32999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33000       };
33001     } catch (Dali::DaliException e) {
33002       {
33003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33004       };
33005     } catch (...) {
33006       {
33007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33008       };
33009     }
33010   }
33011
33012 }
33013
33014
33015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
33016   Dali::Actor arg1 ;
33017   Dali::Actor arg2 ;
33018   Dali::Actor *argp1 ;
33019   Dali::Actor *argp2 ;
33020
33021   argp1 = (Dali::Actor *)jarg1;
33022   if (!argp1) {
33023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33024     return ;
33025   }
33026   arg1 = *argp1;
33027   argp2 = (Dali::Actor *)jarg2;
33028   if (!argp2) {
33029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33030     return ;
33031   }
33032   arg2 = *argp2;
33033   {
33034     try {
33035       arg1.LowerBelow(arg2);
33036     } catch (std::out_of_range& e) {
33037       {
33038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33039       };
33040     } catch (std::exception& e) {
33041       {
33042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33043       };
33044     } catch (Dali::DaliException e) {
33045       {
33046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33047       };
33048     } catch (...) {
33049       {
33050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33051       };
33052     }
33053   }
33054
33055 }
33056
33057
33058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
33059   void * jresult ;
33060   Dali::Actor arg1 ;
33061   Dali::Actor *argp1 ;
33062   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
33063
33064   argp1 = (Dali::Actor *)jarg1;
33065   if (!argp1) {
33066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33067     return 0;
33068   }
33069   arg1 = *argp1;
33070   {
33071     try {
33072       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
33073     } catch (std::out_of_range& e) {
33074       {
33075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33076       };
33077     } catch (std::exception& e) {
33078       {
33079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33080       };
33081     } catch (Dali::DaliException e) {
33082       {
33083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33084       };
33085     } catch (...) {
33086       {
33087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33088       };
33089     }
33090   }
33091
33092   jresult = (void *)result;
33093   return jresult;
33094 }
33095
33096
33097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
33098   void * jresult ;
33099   Dali::Actor *arg1 ;
33100   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
33101
33102   arg1 = (Dali::Actor *)jarg1;
33103   {
33104     try {
33105       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
33106     } catch (std::out_of_range& e) {
33107       {
33108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33109       };
33110     } catch (std::exception& e) {
33111       {
33112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33113       };
33114     } catch (Dali::DaliException e) {
33115       {
33116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33117       };
33118     } catch (...) {
33119       {
33120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33121       };
33122     }
33123   }
33124
33125   jresult = (void *)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::SIZE;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::POSITION;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::POSITION_X;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::POSITION_Y;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::POSITION_Z;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::WORLD_POSITION;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::ORIENTATION;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::SCALE;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::SCALE_X;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33371   int jresult ;
33372   int result;
33373
33374   result = (int)Dali::Actor::Property::SCALE_Y;
33375   jresult = (int)result;
33376   return jresult;
33377 }
33378
33379
33380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33381   int jresult ;
33382   int result;
33383
33384   result = (int)Dali::Actor::Property::SCALE_Z;
33385   jresult = (int)result;
33386   return jresult;
33387 }
33388
33389
33390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33391   int jresult ;
33392   int result;
33393
33394   result = (int)Dali::Actor::Property::WORLD_SCALE;
33395   jresult = (int)result;
33396   return jresult;
33397 }
33398
33399
33400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33401   int jresult ;
33402   int result;
33403
33404   result = (int)Dali::Actor::Property::VISIBLE;
33405   jresult = (int)result;
33406   return jresult;
33407 }
33408
33409
33410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33411   int jresult ;
33412   int result;
33413
33414   result = (int)Dali::Actor::Property::COLOR;
33415   jresult = (int)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33421   int jresult ;
33422   int result;
33423
33424   result = (int)Dali::Actor::Property::COLOR_RED;
33425   jresult = (int)result;
33426   return jresult;
33427 }
33428
33429
33430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33431   int jresult ;
33432   int result;
33433
33434   result = (int)Dali::Actor::Property::COLOR_GREEN;
33435   jresult = (int)result;
33436   return jresult;
33437 }
33438
33439
33440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33441   int jresult ;
33442   int result;
33443
33444   result = (int)Dali::Actor::Property::COLOR_BLUE;
33445   jresult = (int)result;
33446   return jresult;
33447 }
33448
33449
33450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33451   int jresult ;
33452   int result;
33453
33454   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33455   jresult = (int)result;
33456   return jresult;
33457 }
33458
33459
33460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33461   int jresult ;
33462   int result;
33463
33464   result = (int)Dali::Actor::Property::WORLD_COLOR;
33465   jresult = (int)result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33471   int jresult ;
33472   int result;
33473
33474   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33475   jresult = (int)result;
33476   return jresult;
33477 }
33478
33479
33480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33481   int jresult ;
33482   int result;
33483
33484   result = (int)Dali::Actor::Property::NAME;
33485   jresult = (int)result;
33486   return jresult;
33487 }
33488
33489
33490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33491   int jresult ;
33492   int result;
33493
33494   result = (int)Dali::Actor::Property::SENSITIVE;
33495   jresult = (int)result;
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33501   int jresult ;
33502   int result;
33503
33504   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33505   jresult = (int)result;
33506   return jresult;
33507 }
33508
33509
33510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33511   int jresult ;
33512   int result;
33513
33514   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33515   jresult = (int)result;
33516   return jresult;
33517 }
33518
33519
33520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33521   int jresult ;
33522   int result;
33523
33524   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33525   jresult = (int)result;
33526   return jresult;
33527 }
33528
33529
33530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33531   int jresult ;
33532   int result;
33533
33534   result = (int)Dali::Actor::Property::COLOR_MODE;
33535   jresult = (int)result;
33536   return jresult;
33537 }
33538
33539
33540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33541   int jresult ;
33542   int result;
33543
33544   result = (int)Dali::Actor::Property::DRAW_MODE;
33545   jresult = (int)result;
33546   return jresult;
33547 }
33548
33549
33550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33551   int jresult ;
33552   int result;
33553
33554   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33555   jresult = (int)result;
33556   return jresult;
33557 }
33558
33559
33560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33561   int jresult ;
33562   int result;
33563
33564   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33565   jresult = (int)result;
33566   return jresult;
33567 }
33568
33569
33570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33571   int jresult ;
33572   int result;
33573
33574   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33575   jresult = (int)result;
33576   return jresult;
33577 }
33578
33579
33580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33581   int jresult ;
33582   int result;
33583
33584   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33585   jresult = (int)result;
33586   return jresult;
33587 }
33588
33589
33590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33591   int jresult ;
33592   int result;
33593
33594   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33595   jresult = (int)result;
33596   return jresult;
33597 }
33598
33599
33600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33601   int jresult ;
33602   int result;
33603
33604   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33605   jresult = (int)result;
33606   return jresult;
33607 }
33608
33609
33610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33611   int jresult ;
33612   int result;
33613
33614   result = (int)Dali::Actor::Property::PADDING;
33615   jresult = (int)result;
33616   return jresult;
33617 }
33618
33619
33620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33621   int jresult ;
33622   int result;
33623
33624   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33625   jresult = (int)result;
33626   return jresult;
33627 }
33628
33629
33630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33631   int jresult ;
33632   int result;
33633
33634   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33635   jresult = (int)result;
33636   return jresult;
33637 }
33638
33639
33640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33641   int jresult ;
33642   int result;
33643
33644   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33645   jresult = (int)result;
33646   return jresult;
33647 }
33648
33649
33650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33651   int jresult ;
33652   int result;
33653
33654   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33655   jresult = (int)result;
33656   return jresult;
33657 }
33658
33659 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33660
33661   return Dali::Actor::Property::OPACITY;
33662 }
33663
33664 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33665
33666   return Dali::Actor::Property::SCREEN_POSITION;
33667 }
33668
33669 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33670
33671   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33672 }
33673
33674 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33675   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33676 }
33677
33678 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33679   return Dali::Actor::Property::LAYOUT_DIRECTION;
33680 }
33681
33682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33683   void * jresult ;
33684   Dali::Actor::Property *result = 0 ;
33685
33686   {
33687     try {
33688       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33689     } catch (std::out_of_range& e) {
33690       {
33691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33692       };
33693     } catch (std::exception& e) {
33694       {
33695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33696       };
33697     } catch (Dali::DaliException e) {
33698       {
33699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33700       };
33701     } catch (...) {
33702       {
33703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33704       };
33705     }
33706   }
33707
33708   jresult = (void *)result;
33709   return jresult;
33710 }
33711
33712
33713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33714   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33715
33716   arg1 = (Dali::Actor::Property *)jarg1;
33717   {
33718     try {
33719       delete arg1;
33720     } catch (std::out_of_range& e) {
33721       {
33722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33723       };
33724     } catch (std::exception& e) {
33725       {
33726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33727       };
33728     } catch (Dali::DaliException e) {
33729       {
33730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33731       };
33732     } catch (...) {
33733       {
33734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33735       };
33736     }
33737   }
33738
33739 }
33740
33741
33742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33743   void * jresult ;
33744   Dali::Actor *result = 0 ;
33745
33746   {
33747     try {
33748       result = (Dali::Actor *)new Dali::Actor();
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (Dali::DaliException e) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33760       };
33761     } catch (...) {
33762       {
33763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33764       };
33765     }
33766   }
33767
33768   jresult = (void *)result;
33769   return jresult;
33770 }
33771
33772
33773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33774   void * jresult ;
33775   Dali::Actor result;
33776
33777   {
33778     try {
33779       result = Dali::Actor::New();
33780     } catch (std::out_of_range& e) {
33781       {
33782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33783       };
33784     } catch (std::exception& e) {
33785       {
33786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33787       };
33788     } catch (Dali::DaliException e) {
33789       {
33790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33791       };
33792     } catch (...) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33795       };
33796     }
33797   }
33798
33799   jresult = new Dali::Actor((const Dali::Actor &)result);
33800   return jresult;
33801 }
33802
33803
33804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33805   void * jresult ;
33806   Dali::BaseHandle arg1 ;
33807   Dali::BaseHandle *argp1 ;
33808   Dali::Actor result;
33809
33810   argp1 = (Dali::BaseHandle *)jarg1;
33811   if (!argp1) {
33812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33813     return 0;
33814   }
33815   arg1 = *argp1;
33816   {
33817     try {
33818       result = Dali::Actor::DownCast(arg1);
33819     } catch (std::out_of_range& e) {
33820       {
33821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (std::exception& e) {
33824       {
33825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33826       };
33827     } catch (Dali::DaliException e) {
33828       {
33829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33830       };
33831     } catch (...) {
33832       {
33833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33834       };
33835     }
33836   }
33837
33838   jresult = new Dali::Actor((const Dali::Actor &)result);
33839   return jresult;
33840 }
33841
33842
33843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33845
33846   arg1 = (Dali::Actor *)jarg1;
33847   {
33848     try {
33849       delete arg1;
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33857       };
33858     } catch (Dali::DaliException e) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33861       };
33862     } catch (...) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33865       };
33866     }
33867   }
33868
33869 }
33870
33871
33872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33873   void * jresult ;
33874   Dali::Actor *arg1 = 0 ;
33875   Dali::Actor *result = 0 ;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878   if (!arg1) {
33879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33880     return 0;
33881   }
33882   {
33883     try {
33884       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33885     } catch (std::out_of_range& e) {
33886       {
33887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33888       };
33889     } catch (std::exception& e) {
33890       {
33891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33892       };
33893     } catch (Dali::DaliException e) {
33894       {
33895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33896       };
33897     } catch (...) {
33898       {
33899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33900       };
33901     }
33902   }
33903
33904   jresult = (void *)result;
33905   return jresult;
33906 }
33907
33908
33909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33910   void * jresult ;
33911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33912   Dali::Actor *arg2 = 0 ;
33913   Dali::Actor *result = 0 ;
33914
33915   arg1 = (Dali::Actor *)jarg1;
33916   arg2 = (Dali::Actor *)jarg2;
33917   if (!arg2) {
33918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33919     return 0;
33920   }
33921   {
33922     try {
33923       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33924     } catch (std::out_of_range& e) {
33925       {
33926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33927       };
33928     } catch (std::exception& e) {
33929       {
33930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33931       };
33932     } catch (Dali::DaliException e) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33935       };
33936     } catch (...) {
33937       {
33938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33939       };
33940     }
33941   }
33942
33943   jresult = (void *)result;
33944   return jresult;
33945 }
33946
33947
33948 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33949   char * jresult ;
33950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33951   std::string *result = 0 ;
33952   std::string name = "";
33953
33954   arg1 = (Dali::Actor *)jarg1;
33955   {
33956     try {
33957       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33958       result = (std::string *) &name;
33959       jresult = SWIG_csharp_string_callback(result->c_str());
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33967       };
33968     } catch (Dali::DaliException e) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33971       };
33972     } catch (...) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33975       };
33976     }
33977   }
33978   return jresult;
33979 }
33980
33981
33982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984   std::string *arg2 = 0 ;
33985
33986   arg1 = (Dali::Actor *)jarg1;
33987   if (!jarg2) {
33988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33989     return ;
33990   }
33991   std::string arg2_str(jarg2);
33992   arg2 = &arg2_str;
33993   {
33994     try {
33995       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33996     } catch (std::out_of_range& e) {
33997       {
33998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33999       };
34000     } catch (std::exception& e) {
34001       {
34002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34003       };
34004     } catch (Dali::DaliException e) {
34005       {
34006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34007       };
34008     } catch (...) {
34009       {
34010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34011       };
34012     }
34013   }
34014
34015
34016   //argout typemap for const std::string&
34017
34018 }
34019
34020
34021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
34022   unsigned int jresult ;
34023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34024   unsigned int result;
34025
34026   arg1 = (Dali::Actor *)jarg1;
34027
34028   if(!arg1) {
34029     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
34030     return -1;
34031   }
34032
34033   {
34034     try {
34035       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
34036     } catch (std::out_of_range& e) {
34037       {
34038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34039       };
34040     } catch (std::exception& e) {
34041       {
34042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34043       };
34044     } catch (Dali::DaliException e) {
34045       {
34046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34047       };
34048     } catch (...) {
34049       {
34050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34051       };
34052     }
34053   }
34054
34055   jresult = result;
34056   return jresult;
34057 }
34058
34059
34060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
34061   unsigned int jresult ;
34062   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34063   bool result;
34064
34065   arg1 = (Dali::Actor *)jarg1;
34066   {
34067     try {
34068       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
34069     } catch (std::out_of_range& e) {
34070       {
34071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34072       };
34073     } catch (std::exception& e) {
34074       {
34075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34076       };
34077     } catch (Dali::DaliException e) {
34078       {
34079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34080       };
34081     } catch (...) {
34082       {
34083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34084       };
34085     }
34086   }
34087
34088   jresult = result;
34089   return jresult;
34090 }
34091
34092
34093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
34094   unsigned int jresult ;
34095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34096   bool result;
34097
34098   arg1 = (Dali::Actor *)jarg1;
34099   {
34100     try {
34101       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
34102     } catch (std::out_of_range& e) {
34103       {
34104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34105       };
34106     } catch (std::exception& e) {
34107       {
34108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34109       };
34110     } catch (Dali::DaliException e) {
34111       {
34112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34113       };
34114     } catch (...) {
34115       {
34116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34117       };
34118     }
34119   }
34120
34121   jresult = result;
34122   return jresult;
34123 }
34124
34125
34126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
34127   unsigned int jresult ;
34128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34129   bool result;
34130
34131   arg1 = (Dali::Actor *)jarg1;
34132   {
34133     try {
34134       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
34135     } catch (std::out_of_range& e) {
34136       {
34137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34138       };
34139     } catch (std::exception& e) {
34140       {
34141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34142       };
34143     } catch (Dali::DaliException e) {
34144       {
34145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34146       };
34147     } catch (...) {
34148       {
34149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34150       };
34151     }
34152   }
34153
34154   jresult = result;
34155   return jresult;
34156 }
34157
34158
34159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34160   void * jresult ;
34161   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34162   Dali::Layer result;
34163
34164   arg1 = (Dali::Actor *)jarg1;
34165   {
34166     try {
34167       result = (arg1)->GetLayer();
34168     } catch (std::out_of_range& e) {
34169       {
34170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34171       };
34172     } catch (std::exception& e) {
34173       {
34174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34175       };
34176     } catch (Dali::DaliException e) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34179       };
34180     } catch (...) {
34181       {
34182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34183       };
34184     }
34185   }
34186
34187   jresult = new Dali::Layer((const Dali::Layer &)result);
34188   return jresult;
34189 }
34190
34191
34192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34194   Dali::Actor arg2 ;
34195   Dali::Actor *argp2 ;
34196
34197   arg1 = (Dali::Actor *)jarg1;
34198   argp2 = (Dali::Actor *)jarg2;
34199   if (!argp2) {
34200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34201     return ;
34202   }
34203   arg2 = *argp2;
34204   {
34205     try {
34206       (arg1)->Add(arg2);
34207     } catch (std::out_of_range& e) {
34208       {
34209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34210       };
34211     } catch (std::exception& e) {
34212       {
34213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34214       };
34215     } catch (Dali::DaliException e) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34218       };
34219     } catch (...) {
34220       {
34221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34222       };
34223     }
34224   }
34225
34226 }
34227
34228
34229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34231   Dali::Actor arg2 ;
34232   Dali::Actor *argp2 ;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   argp2 = (Dali::Actor *)jarg2;
34236   if (!argp2) {
34237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34238     return ;
34239   }
34240   arg2 = *argp2;
34241   {
34242     try {
34243       (arg1)->Remove(arg2);
34244     } catch (std::out_of_range& e) {
34245       {
34246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34247       };
34248     } catch (std::exception& e) {
34249       {
34250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34251       };
34252     } catch (Dali::DaliException e) {
34253       {
34254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34255       };
34256     } catch (...) {
34257       {
34258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34259       };
34260     }
34261   }
34262
34263 }
34264
34265
34266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34268
34269   arg1 = (Dali::Actor *)jarg1;
34270   {
34271     try {
34272       (arg1)->Unparent();
34273     } catch (std::out_of_range& e) {
34274       {
34275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34276       };
34277     } catch (std::exception& e) {
34278       {
34279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34280       };
34281     } catch (Dali::DaliException e) {
34282       {
34283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34284       };
34285     } catch (...) {
34286       {
34287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34288       };
34289     }
34290   }
34291
34292 }
34293
34294
34295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34296   unsigned int jresult ;
34297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34298   unsigned int result;
34299
34300   arg1 = (Dali::Actor *)jarg1;
34301   {
34302     try {
34303       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34304     } catch (std::out_of_range& e) {
34305       {
34306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34307       };
34308     } catch (std::exception& e) {
34309       {
34310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34311       };
34312     } catch (Dali::DaliException e) {
34313       {
34314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34315       };
34316     } catch (...) {
34317       {
34318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34319       };
34320     }
34321   }
34322
34323   jresult = result;
34324   return jresult;
34325 }
34326
34327
34328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34329   void * jresult ;
34330   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34331   unsigned int arg2 ;
34332   Dali::Actor result;
34333
34334   arg1 = (Dali::Actor *)jarg1;
34335   arg2 = (unsigned int)jarg2;
34336   {
34337     try {
34338       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34339     } catch (std::out_of_range& e) {
34340       {
34341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34342       };
34343     } catch (std::exception& e) {
34344       {
34345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34346       };
34347     } catch (Dali::DaliException e) {
34348       {
34349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34350       };
34351     } catch (...) {
34352       {
34353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34354       };
34355     }
34356   }
34357
34358   jresult = new Dali::Actor((const Dali::Actor &)result);
34359   return jresult;
34360 }
34361
34362
34363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34364   void * jresult ;
34365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34366   std::string *arg2 = 0 ;
34367   Dali::Actor result;
34368
34369   arg1 = (Dali::Actor *)jarg1;
34370   if (!jarg2) {
34371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34372     return 0;
34373   }
34374   std::string arg2_str(jarg2);
34375   arg2 = &arg2_str;
34376   {
34377     try {
34378       result = (arg1)->FindChildByName((std::string const &)*arg2);
34379     } catch (std::out_of_range& e) {
34380       {
34381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34382       };
34383     } catch (std::exception& e) {
34384       {
34385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34386       };
34387     } catch (Dali::DaliException e) {
34388       {
34389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34390       };
34391     } catch (...) {
34392       {
34393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34394       };
34395     }
34396   }
34397
34398   jresult = new Dali::Actor((const Dali::Actor &)result);
34399
34400   //argout typemap for const std::string&
34401
34402   return jresult;
34403 }
34404
34405
34406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34407   void * jresult ;
34408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34409   unsigned int arg2 ;
34410   Dali::Actor result;
34411
34412   arg1 = (Dali::Actor *)jarg1;
34413   arg2 = (unsigned int)jarg2;
34414   {
34415     try {
34416       result = (arg1)->FindChildById(arg2);
34417     } catch (std::out_of_range& e) {
34418       {
34419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34420       };
34421     } catch (std::exception& e) {
34422       {
34423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34424       };
34425     } catch (Dali::DaliException e) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34428       };
34429     } catch (...) {
34430       {
34431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34432       };
34433     }
34434   }
34435
34436   jresult = new Dali::Actor((const Dali::Actor &)result);
34437   return jresult;
34438 }
34439
34440
34441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34442   void * jresult ;
34443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34444   Dali::Actor result;
34445
34446   arg1 = (Dali::Actor *)jarg1;
34447   {
34448     try {
34449       result = ((Dali::Actor const *)arg1)->GetParent();
34450     } catch (std::out_of_range& e) {
34451       {
34452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34453       };
34454     } catch (std::exception& e) {
34455       {
34456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34457       };
34458     } catch (Dali::DaliException e) {
34459       {
34460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34461       };
34462     } catch (...) {
34463       {
34464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34465       };
34466     }
34467   }
34468
34469   jresult = new Dali::Actor((const Dali::Actor &)result);
34470   return jresult;
34471 }
34472
34473
34474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34476   Dali::Vector3 *arg2 = 0 ;
34477
34478   arg1 = (Dali::Actor *)jarg1;
34479   arg2 = (Dali::Vector3 *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34482     return ;
34483   }
34484   {
34485     try {
34486       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34494       };
34495     } catch (Dali::DaliException e) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34498       };
34499     } catch (...) {
34500       {
34501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34502       };
34503     }
34504   }
34505
34506 }
34507
34508
34509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34510   void * jresult ;
34511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34512   Dali::Vector3 result;
34513
34514   arg1 = (Dali::Actor *)jarg1;
34515   {
34516     try {
34517       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34518     } catch (std::out_of_range& e) {
34519       {
34520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34521       };
34522     } catch (std::exception& e) {
34523       {
34524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34525       };
34526     } catch (Dali::DaliException e) {
34527       {
34528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34529       };
34530     } catch (...) {
34531       {
34532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34533       };
34534     }
34535   }
34536
34537   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34538   return jresult;
34539 }
34540
34541
34542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34544   Dali::Vector3 *arg2 = 0 ;
34545
34546   arg1 = (Dali::Actor *)jarg1;
34547   arg2 = (Dali::Vector3 *)jarg2;
34548   if (!arg2) {
34549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34550     return ;
34551   }
34552   {
34553     try {
34554       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34555     } catch (std::out_of_range& e) {
34556       {
34557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34558       };
34559     } catch (std::exception& e) {
34560       {
34561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34562       };
34563     } catch (Dali::DaliException e) {
34564       {
34565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34566       };
34567     } catch (...) {
34568       {
34569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34570       };
34571     }
34572   }
34573
34574 }
34575
34576
34577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34578   void * jresult ;
34579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34580   Dali::Vector3 result;
34581
34582   arg1 = (Dali::Actor *)jarg1;
34583   {
34584     try {
34585       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34586     } catch (std::out_of_range& e) {
34587       {
34588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34589       };
34590     } catch (std::exception& e) {
34591       {
34592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34593       };
34594     } catch (Dali::DaliException e) {
34595       {
34596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34597       };
34598     } catch (...) {
34599       {
34600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34601       };
34602     }
34603   }
34604
34605   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34606   return jresult;
34607 }
34608
34609
34610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34612   float arg2 ;
34613   float arg3 ;
34614
34615   arg1 = (Dali::Actor *)jarg1;
34616   arg2 = (float)jarg2;
34617   arg3 = (float)jarg3;
34618   {
34619     try {
34620       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34621     } catch (std::out_of_range& e) {
34622       {
34623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34624       };
34625     } catch (std::exception& e) {
34626       {
34627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34628       };
34629     } catch (Dali::DaliException e) {
34630       {
34631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34632       };
34633     } catch (...) {
34634       {
34635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34636       };
34637     }
34638   }
34639
34640 }
34641
34642
34643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34645   float arg2 ;
34646   float arg3 ;
34647   float arg4 ;
34648
34649   arg1 = (Dali::Actor *)jarg1;
34650   arg2 = (float)jarg2;
34651   arg3 = (float)jarg3;
34652   arg4 = (float)jarg4;
34653   {
34654     try {
34655       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34656     } catch (std::out_of_range& e) {
34657       {
34658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34659       };
34660     } catch (std::exception& e) {
34661       {
34662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34663       };
34664     } catch (Dali::DaliException e) {
34665       {
34666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34667       };
34668     } catch (...) {
34669       {
34670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34671       };
34672     }
34673   }
34674
34675 }
34676
34677
34678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34679   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34680   Dali::Vector2 *arg2 = 0 ;
34681
34682   arg1 = (Dali::Actor *)jarg1;
34683   arg2 = (Dali::Vector2 *)jarg2;
34684   if (!arg2) {
34685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34686     return ;
34687   }
34688   {
34689     try {
34690       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34691     } catch (std::out_of_range& e) {
34692       {
34693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34694       };
34695     } catch (std::exception& e) {
34696       {
34697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34698       };
34699     } catch (Dali::DaliException e) {
34700       {
34701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34702       };
34703     } catch (...) {
34704       {
34705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34706       };
34707     }
34708   }
34709
34710 }
34711
34712
34713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34715   Dali::Vector3 *arg2 = 0 ;
34716
34717   arg1 = (Dali::Actor *)jarg1;
34718   arg2 = (Dali::Vector3 *)jarg2;
34719   if (!arg2) {
34720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34721     return ;
34722   }
34723   {
34724     try {
34725       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34726     } catch (std::out_of_range& e) {
34727       {
34728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34729       };
34730     } catch (std::exception& e) {
34731       {
34732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34733       };
34734     } catch (Dali::DaliException e) {
34735       {
34736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34737       };
34738     } catch (...) {
34739       {
34740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34741       };
34742     }
34743   }
34744
34745 }
34746
34747
34748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34749   void * jresult ;
34750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34751   Dali::Vector3 result;
34752
34753   arg1 = (Dali::Actor *)jarg1;
34754   {
34755     try {
34756       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34757     } catch (std::out_of_range& e) {
34758       {
34759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34760       };
34761     } catch (std::exception& e) {
34762       {
34763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34764       };
34765     } catch (Dali::DaliException e) {
34766       {
34767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34768       };
34769     } catch (...) {
34770       {
34771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34772       };
34773     }
34774   }
34775
34776   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34777   return jresult;
34778 }
34779
34780
34781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34782   void * jresult ;
34783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34784   Dali::Vector3 result;
34785
34786   arg1 = (Dali::Actor *)jarg1;
34787   {
34788     try {
34789       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34790     } catch (std::out_of_range& e) {
34791       {
34792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34793       };
34794     } catch (std::exception& e) {
34795       {
34796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34797       };
34798     } catch (Dali::DaliException e) {
34799       {
34800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34801       };
34802     } catch (...) {
34803       {
34804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34805       };
34806     }
34807   }
34808
34809   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34810   return jresult;
34811 }
34812
34813
34814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34815   void * jresult ;
34816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34817   Dali::Vector3 result;
34818
34819   arg1 = (Dali::Actor *)jarg1;
34820   {
34821     try {
34822       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34823     } catch (std::out_of_range& e) {
34824       {
34825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34826       };
34827     } catch (std::exception& e) {
34828       {
34829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34830       };
34831     } catch (Dali::DaliException e) {
34832       {
34833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34834       };
34835     } catch (...) {
34836       {
34837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34838       };
34839     }
34840   }
34841
34842   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34843   return jresult;
34844 }
34845
34846
34847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34849   float arg2 ;
34850   float arg3 ;
34851
34852   arg1 = (Dali::Actor *)jarg1;
34853   arg2 = (float)jarg2;
34854   arg3 = (float)jarg3;
34855   {
34856     try {
34857       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34858     } catch (std::out_of_range& e) {
34859       {
34860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34861       };
34862     } catch (std::exception& e) {
34863       {
34864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34865       };
34866     } catch (Dali::DaliException e) {
34867       {
34868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34873       };
34874     }
34875   }
34876
34877 }
34878
34879
34880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34882   float arg2 ;
34883   float arg3 ;
34884   float arg4 ;
34885
34886   arg1 = (Dali::Actor *)jarg1;
34887   arg2 = (float)jarg2;
34888   arg3 = (float)jarg3;
34889   arg4 = (float)jarg4;
34890   {
34891     try {
34892       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34893     } catch (std::out_of_range& e) {
34894       {
34895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34896       };
34897     } catch (std::exception& e) {
34898       {
34899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34900       };
34901     } catch (Dali::DaliException e) {
34902       {
34903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34904       };
34905     } catch (...) {
34906       {
34907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34908       };
34909     }
34910   }
34911
34912 }
34913
34914
34915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34917   Dali::Vector3 *arg2 = 0 ;
34918
34919   arg1 = (Dali::Actor *)jarg1;
34920   arg2 = (Dali::Vector3 *)jarg2;
34921   if (!arg2) {
34922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34923     return ;
34924   }
34925   {
34926     try {
34927       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34928     } catch (std::out_of_range& e) {
34929       {
34930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34931       };
34932     } catch (std::exception& e) {
34933       {
34934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34935       };
34936     } catch (Dali::DaliException e) {
34937       {
34938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34939       };
34940     } catch (...) {
34941       {
34942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34943       };
34944     }
34945   }
34946
34947 }
34948
34949
34950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34952   float arg2 ;
34953
34954   arg1 = (Dali::Actor *)jarg1;
34955   arg2 = (float)jarg2;
34956   {
34957     try {
34958       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34966       };
34967     } catch (Dali::DaliException e) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34970       };
34971     } catch (...) {
34972       {
34973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34974       };
34975     }
34976   }
34977
34978 }
34979
34980
34981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34983   float arg2 ;
34984
34985   arg1 = (Dali::Actor *)jarg1;
34986   arg2 = (float)jarg2;
34987   {
34988     try {
34989       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
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_SetZ(void * jarg1, float jarg2) {
35013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35014   float arg2 ;
35015
35016   arg1 = (Dali::Actor *)jarg1;
35017   arg2 = (float)jarg2;
35018   {
35019     try {
35020       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
35021     } catch (std::out_of_range& e) {
35022       {
35023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35024       };
35025     } catch (std::exception& e) {
35026       {
35027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35028       };
35029     } catch (Dali::DaliException e) {
35030       {
35031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35032       };
35033     } catch (...) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35036       };
35037     }
35038   }
35039
35040 }
35041
35042
35043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
35044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35045   Dali::Vector3 *arg2 = 0 ;
35046
35047   arg1 = (Dali::Actor *)jarg1;
35048   arg2 = (Dali::Vector3 *)jarg2;
35049   if (!arg2) {
35050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35051     return ;
35052   }
35053   {
35054     try {
35055       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
35056     } catch (std::out_of_range& e) {
35057       {
35058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35059       };
35060     } catch (std::exception& e) {
35061       {
35062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35063       };
35064     } catch (Dali::DaliException e) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35067       };
35068     } catch (...) {
35069       {
35070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35071       };
35072     }
35073   }
35074
35075 }
35076
35077
35078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
35079   void * jresult ;
35080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35081   Dali::Vector3 result;
35082
35083   arg1 = (Dali::Actor *)jarg1;
35084   {
35085     try {
35086       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
35087     } catch (std::out_of_range& e) {
35088       {
35089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35090       };
35091     } catch (std::exception& e) {
35092       {
35093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35094       };
35095     } catch (Dali::DaliException e) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35098       };
35099     } catch (...) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35102       };
35103     }
35104   }
35105
35106   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35107   return jresult;
35108 }
35109
35110
35111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
35112   void * jresult ;
35113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35114   Dali::Vector3 result;
35115
35116   arg1 = (Dali::Actor *)jarg1;
35117   {
35118     try {
35119       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
35120     } catch (std::out_of_range& e) {
35121       {
35122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35123       };
35124     } catch (std::exception& e) {
35125       {
35126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35127       };
35128     } catch (Dali::DaliException e) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35131       };
35132     } catch (...) {
35133       {
35134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35135       };
35136     }
35137   }
35138
35139   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35140   return jresult;
35141 }
35142
35143
35144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
35145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35146   bool arg2 ;
35147
35148   arg1 = (Dali::Actor *)jarg1;
35149   arg2 = jarg2 ? true : false;
35150   {
35151     try {
35152       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
35153     } catch (std::out_of_range& e) {
35154       {
35155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (std::exception& e) {
35158       {
35159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (Dali::DaliException e) {
35162       {
35163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35164       };
35165     } catch (...) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35168       };
35169     }
35170   }
35171
35172 }
35173
35174
35175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35176   unsigned int jresult ;
35177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35178   bool result;
35179
35180   arg1 = (Dali::Actor *)jarg1;
35181   {
35182     try {
35183       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35184     } catch (std::out_of_range& e) {
35185       {
35186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35187       };
35188     } catch (std::exception& e) {
35189       {
35190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35191       };
35192     } catch (Dali::DaliException e) {
35193       {
35194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35195       };
35196     } catch (...) {
35197       {
35198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35199       };
35200     }
35201   }
35202
35203   jresult = result;
35204   return jresult;
35205 }
35206
35207
35208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35210   Dali::Degree *arg2 = 0 ;
35211   Dali::Vector3 *arg3 = 0 ;
35212
35213   arg1 = (Dali::Actor *)jarg1;
35214   arg2 = (Dali::Degree *)jarg2;
35215   if (!arg2) {
35216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35217     return ;
35218   }
35219   arg3 = (Dali::Vector3 *)jarg3;
35220   if (!arg3) {
35221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35222     return ;
35223   }
35224   {
35225     try {
35226       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
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_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35251   Dali::Radian *arg2 = 0 ;
35252   Dali::Vector3 *arg3 = 0 ;
35253
35254   arg1 = (Dali::Actor *)jarg1;
35255   arg2 = (Dali::Radian *)jarg2;
35256   if (!arg2) {
35257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35258     return ;
35259   }
35260   arg3 = (Dali::Vector3 *)jarg3;
35261   if (!arg3) {
35262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35263     return ;
35264   }
35265   {
35266     try {
35267       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35268     } catch (std::out_of_range& e) {
35269       {
35270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35271       };
35272     } catch (std::exception& e) {
35273       {
35274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35275       };
35276     } catch (Dali::DaliException e) {
35277       {
35278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35279       };
35280     } catch (...) {
35281       {
35282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35283       };
35284     }
35285   }
35286
35287 }
35288
35289
35290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35292   Dali::Quaternion *arg2 = 0 ;
35293
35294   arg1 = (Dali::Actor *)jarg1;
35295   arg2 = (Dali::Quaternion *)jarg2;
35296   if (!arg2) {
35297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35298     return ;
35299   }
35300   {
35301     try {
35302       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35303     } catch (std::out_of_range& e) {
35304       {
35305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35306       };
35307     } catch (std::exception& e) {
35308       {
35309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35310       };
35311     } catch (Dali::DaliException e) {
35312       {
35313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35318       };
35319     }
35320   }
35321
35322 }
35323
35324
35325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35327   Dali::Degree *arg2 = 0 ;
35328   Dali::Vector3 *arg3 = 0 ;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   arg2 = (Dali::Degree *)jarg2;
35332   if (!arg2) {
35333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35334     return ;
35335   }
35336   arg3 = (Dali::Vector3 *)jarg3;
35337   if (!arg3) {
35338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35339     return ;
35340   }
35341   {
35342     try {
35343       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35344     } catch (std::out_of_range& e) {
35345       {
35346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35347       };
35348     } catch (std::exception& e) {
35349       {
35350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35351       };
35352     } catch (Dali::DaliException e) {
35353       {
35354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35355       };
35356     } catch (...) {
35357       {
35358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35359       };
35360     }
35361   }
35362
35363 }
35364
35365
35366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35368   Dali::Radian *arg2 = 0 ;
35369   Dali::Vector3 *arg3 = 0 ;
35370
35371   arg1 = (Dali::Actor *)jarg1;
35372   arg2 = (Dali::Radian *)jarg2;
35373   if (!arg2) {
35374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35375     return ;
35376   }
35377   arg3 = (Dali::Vector3 *)jarg3;
35378   if (!arg3) {
35379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35380     return ;
35381   }
35382   {
35383     try {
35384       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35385     } catch (std::out_of_range& e) {
35386       {
35387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35388       };
35389     } catch (std::exception& e) {
35390       {
35391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35392       };
35393     } catch (Dali::DaliException e) {
35394       {
35395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35396       };
35397     } catch (...) {
35398       {
35399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35400       };
35401     }
35402   }
35403
35404 }
35405
35406
35407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35409   Dali::Quaternion *arg2 = 0 ;
35410
35411   arg1 = (Dali::Actor *)jarg1;
35412   arg2 = (Dali::Quaternion *)jarg2;
35413   if (!arg2) {
35414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35415     return ;
35416   }
35417   {
35418     try {
35419       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35420     } catch (std::out_of_range& e) {
35421       {
35422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35423       };
35424     } catch (std::exception& e) {
35425       {
35426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35427       };
35428     } catch (Dali::DaliException e) {
35429       {
35430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35431       };
35432     } catch (...) {
35433       {
35434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35435       };
35436     }
35437   }
35438
35439 }
35440
35441
35442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35443   void * jresult ;
35444   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35445   Dali::Quaternion result;
35446
35447   arg1 = (Dali::Actor *)jarg1;
35448   {
35449     try {
35450       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35451     } catch (std::out_of_range& e) {
35452       {
35453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35454       };
35455     } catch (std::exception& e) {
35456       {
35457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35458       };
35459     } catch (Dali::DaliException e) {
35460       {
35461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35462       };
35463     } catch (...) {
35464       {
35465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35466       };
35467     }
35468   }
35469
35470   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35471   return jresult;
35472 }
35473
35474
35475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35477   bool arg2 ;
35478
35479   arg1 = (Dali::Actor *)jarg1;
35480   arg2 = jarg2 ? true : false;
35481   {
35482     try {
35483       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35484     } catch (std::out_of_range& e) {
35485       {
35486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35487       };
35488     } catch (std::exception& e) {
35489       {
35490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35491       };
35492     } catch (Dali::DaliException e) {
35493       {
35494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35495       };
35496     } catch (...) {
35497       {
35498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35499       };
35500     }
35501   }
35502
35503 }
35504
35505
35506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35507   unsigned int jresult ;
35508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35509   bool result;
35510
35511   arg1 = (Dali::Actor *)jarg1;
35512   {
35513     try {
35514       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35515     } catch (std::out_of_range& e) {
35516       {
35517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35518       };
35519     } catch (std::exception& e) {
35520       {
35521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35522       };
35523     } catch (Dali::DaliException e) {
35524       {
35525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35526       };
35527     } catch (...) {
35528       {
35529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35530       };
35531     }
35532   }
35533
35534   jresult = result;
35535   return jresult;
35536 }
35537
35538
35539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35540   void * jresult ;
35541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35542   Dali::Quaternion result;
35543
35544   arg1 = (Dali::Actor *)jarg1;
35545   {
35546     try {
35547       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35548     } catch (std::out_of_range& e) {
35549       {
35550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35551       };
35552     } catch (std::exception& e) {
35553       {
35554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35555       };
35556     } catch (Dali::DaliException e) {
35557       {
35558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35559       };
35560     } catch (...) {
35561       {
35562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35563       };
35564     }
35565   }
35566
35567   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35568   return jresult;
35569 }
35570
35571
35572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35573   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35574   float arg2 ;
35575
35576   arg1 = (Dali::Actor *)jarg1;
35577   arg2 = (float)jarg2;
35578   {
35579     try {
35580       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35581     } catch (std::out_of_range& e) {
35582       {
35583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35584       };
35585     } catch (std::exception& e) {
35586       {
35587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35588       };
35589     } catch (Dali::DaliException e) {
35590       {
35591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35592       };
35593     } catch (...) {
35594       {
35595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35596       };
35597     }
35598   }
35599
35600 }
35601
35602
35603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35605   float arg2 ;
35606   float arg3 ;
35607   float arg4 ;
35608
35609   arg1 = (Dali::Actor *)jarg1;
35610   arg2 = (float)jarg2;
35611   arg3 = (float)jarg3;
35612   arg4 = (float)jarg4;
35613   {
35614     try {
35615       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35616     } catch (std::out_of_range& e) {
35617       {
35618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35619       };
35620     } catch (std::exception& e) {
35621       {
35622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35623       };
35624     } catch (Dali::DaliException e) {
35625       {
35626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35627       };
35628     } catch (...) {
35629       {
35630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35631       };
35632     }
35633   }
35634
35635 }
35636
35637
35638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35640   Dali::Vector3 *arg2 = 0 ;
35641
35642   arg1 = (Dali::Actor *)jarg1;
35643   arg2 = (Dali::Vector3 *)jarg2;
35644   if (!arg2) {
35645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35646     return ;
35647   }
35648   {
35649     try {
35650       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35651     } catch (std::out_of_range& e) {
35652       {
35653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35654       };
35655     } catch (std::exception& e) {
35656       {
35657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35658       };
35659     } catch (Dali::DaliException e) {
35660       {
35661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35662       };
35663     } catch (...) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35666       };
35667     }
35668   }
35669
35670 }
35671
35672
35673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35675   Dali::Vector3 *arg2 = 0 ;
35676
35677   arg1 = (Dali::Actor *)jarg1;
35678   arg2 = (Dali::Vector3 *)jarg2;
35679   if (!arg2) {
35680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35681     return ;
35682   }
35683   {
35684     try {
35685       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35686     } catch (std::out_of_range& e) {
35687       {
35688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35689       };
35690     } catch (std::exception& e) {
35691       {
35692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35693       };
35694     } catch (Dali::DaliException e) {
35695       {
35696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35697       };
35698     } catch (...) {
35699       {
35700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35701       };
35702     }
35703   }
35704
35705 }
35706
35707
35708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35709   void * jresult ;
35710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35711   Dali::Vector3 result;
35712
35713   arg1 = (Dali::Actor *)jarg1;
35714   {
35715     try {
35716       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35717     } catch (std::out_of_range& e) {
35718       {
35719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35720       };
35721     } catch (std::exception& e) {
35722       {
35723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35724       };
35725     } catch (Dali::DaliException e) {
35726       {
35727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35728       };
35729     } catch (...) {
35730       {
35731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35732       };
35733     }
35734   }
35735
35736   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35737   return jresult;
35738 }
35739
35740
35741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35742   void * jresult ;
35743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35744   Dali::Vector3 result;
35745
35746   arg1 = (Dali::Actor *)jarg1;
35747   {
35748     try {
35749       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35750     } catch (std::out_of_range& e) {
35751       {
35752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35753       };
35754     } catch (std::exception& e) {
35755       {
35756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35757       };
35758     } catch (Dali::DaliException e) {
35759       {
35760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35761       };
35762     } catch (...) {
35763       {
35764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35765       };
35766     }
35767   }
35768
35769   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35770   return jresult;
35771 }
35772
35773
35774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35776   bool arg2 ;
35777
35778   arg1 = (Dali::Actor *)jarg1;
35779   arg2 = jarg2 ? true : false;
35780   {
35781     try {
35782       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35783     } catch (std::out_of_range& e) {
35784       {
35785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35786       };
35787     } catch (std::exception& e) {
35788       {
35789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35790       };
35791     } catch (Dali::DaliException e) {
35792       {
35793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35794       };
35795     } catch (...) {
35796       {
35797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35798       };
35799     }
35800   }
35801
35802 }
35803
35804
35805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35806   unsigned int jresult ;
35807   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35808   bool result;
35809
35810   arg1 = (Dali::Actor *)jarg1;
35811   {
35812     try {
35813       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35814     } catch (std::out_of_range& e) {
35815       {
35816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35817       };
35818     } catch (std::exception& e) {
35819       {
35820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35821       };
35822     } catch (Dali::DaliException e) {
35823       {
35824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35825       };
35826     } catch (...) {
35827       {
35828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35829       };
35830     }
35831   }
35832
35833   jresult = result;
35834   return jresult;
35835 }
35836
35837
35838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35839   void * jresult ;
35840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35841   Dali::Matrix result;
35842
35843   arg1 = (Dali::Actor *)jarg1;
35844   {
35845     try {
35846       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35847     } catch (std::out_of_range& e) {
35848       {
35849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35850       };
35851     } catch (std::exception& e) {
35852       {
35853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35854       };
35855     } catch (Dali::DaliException e) {
35856       {
35857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35858       };
35859     } catch (...) {
35860       {
35861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35862       };
35863     }
35864   }
35865
35866   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35867   return jresult;
35868 }
35869
35870
35871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35873   bool arg2 ;
35874
35875   arg1 = (Dali::Actor *)jarg1;
35876   arg2 = jarg2 ? true : false;
35877   {
35878     try {
35879       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35880     } catch (std::out_of_range& e) {
35881       {
35882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35883       };
35884     } catch (std::exception& e) {
35885       {
35886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35887       };
35888     } catch (Dali::DaliException e) {
35889       {
35890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35891       };
35892     } catch (...) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35895       };
35896     }
35897   }
35898
35899 }
35900
35901
35902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35903   unsigned int jresult ;
35904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35905   bool result;
35906
35907   arg1 = (Dali::Actor *)jarg1;
35908   {
35909     try {
35910       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35911     } catch (std::out_of_range& e) {
35912       {
35913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35914       };
35915     } catch (std::exception& e) {
35916       {
35917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35918       };
35919     } catch (Dali::DaliException e) {
35920       {
35921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35922       };
35923     } catch (...) {
35924       {
35925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35926       };
35927     }
35928   }
35929
35930   jresult = result;
35931   return jresult;
35932 }
35933
35934
35935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35936   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35937   float arg2 ;
35938
35939   arg1 = (Dali::Actor *)jarg1;
35940   arg2 = (float)jarg2;
35941   {
35942     try {
35943       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35944     } catch (std::out_of_range& e) {
35945       {
35946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35947       };
35948     } catch (std::exception& e) {
35949       {
35950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35951       };
35952     } catch (Dali::DaliException e) {
35953       {
35954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35955       };
35956     } catch (...) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35959       };
35960     }
35961   }
35962
35963 }
35964
35965
35966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35967   float jresult ;
35968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35969   float result;
35970
35971   arg1 = (Dali::Actor *)jarg1;
35972   {
35973     try {
35974       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35975     } catch (std::out_of_range& e) {
35976       {
35977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35978       };
35979     } catch (std::exception& e) {
35980       {
35981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35982       };
35983     } catch (Dali::DaliException e) {
35984       {
35985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35986       };
35987     } catch (...) {
35988       {
35989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35990       };
35991     }
35992   }
35993
35994   jresult = result;
35995   return jresult;
35996 }
35997
35998
35999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
36000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36001   Dali::Vector4 *arg2 = 0 ;
36002
36003   arg1 = (Dali::Actor *)jarg1;
36004   arg2 = (Dali::Vector4 *)jarg2;
36005   if (!arg2) {
36006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
36007     return ;
36008   }
36009   {
36010     try {
36011       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
36012     } catch (std::out_of_range& e) {
36013       {
36014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36015       };
36016     } catch (std::exception& e) {
36017       {
36018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36019       };
36020     } catch (Dali::DaliException e) {
36021       {
36022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36023       };
36024     } catch (...) {
36025       {
36026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36027       };
36028     }
36029   }
36030
36031 }
36032
36033
36034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
36035   void * jresult ;
36036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36037   Dali::Vector4 result;
36038
36039   arg1 = (Dali::Actor *)jarg1;
36040   {
36041     try {
36042       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
36043     } catch (std::out_of_range& e) {
36044       {
36045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36046       };
36047     } catch (std::exception& e) {
36048       {
36049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36050       };
36051     } catch (Dali::DaliException e) {
36052       {
36053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36054       };
36055     } catch (...) {
36056       {
36057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36058       };
36059     }
36060   }
36061
36062   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36063   return jresult;
36064 }
36065
36066
36067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
36068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36069   Dali::ColorMode arg2 ;
36070
36071   arg1 = (Dali::Actor *)jarg1;
36072   arg2 = (Dali::ColorMode)jarg2;
36073   {
36074     try {
36075       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
36076     } catch (std::out_of_range& e) {
36077       {
36078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36079       };
36080     } catch (std::exception& e) {
36081       {
36082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36083       };
36084     } catch (Dali::DaliException e) {
36085       {
36086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36087       };
36088     } catch (...) {
36089       {
36090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36091       };
36092     }
36093   }
36094
36095 }
36096
36097
36098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
36099   int jresult ;
36100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36101   Dali::ColorMode result;
36102
36103   arg1 = (Dali::Actor *)jarg1;
36104   {
36105     try {
36106       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
36107     } catch (std::out_of_range& e) {
36108       {
36109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36110       };
36111     } catch (std::exception& e) {
36112       {
36113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36114       };
36115     } catch (Dali::DaliException e) {
36116       {
36117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36118       };
36119     } catch (...) {
36120       {
36121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36122       };
36123     }
36124   }
36125
36126   jresult = (int)result;
36127   return jresult;
36128 }
36129
36130
36131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
36132   void * jresult ;
36133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36134   Dali::Vector4 result;
36135
36136   arg1 = (Dali::Actor *)jarg1;
36137   {
36138     try {
36139       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
36140     } catch (std::out_of_range& e) {
36141       {
36142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36143       };
36144     } catch (std::exception& e) {
36145       {
36146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36147       };
36148     } catch (Dali::DaliException e) {
36149       {
36150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36151       };
36152     } catch (...) {
36153       {
36154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36155       };
36156     }
36157   }
36158
36159   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36160   return jresult;
36161 }
36162
36163
36164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36165   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36166   Dali::DrawMode::Type arg2 ;
36167
36168   arg1 = (Dali::Actor *)jarg1;
36169   arg2 = (Dali::DrawMode::Type)jarg2;
36170   {
36171     try {
36172       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
36173     } catch (std::out_of_range& e) {
36174       {
36175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36176       };
36177     } catch (std::exception& e) {
36178       {
36179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (Dali::DaliException e) {
36182       {
36183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36184       };
36185     } catch (...) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36188       };
36189     }
36190   }
36191
36192 }
36193
36194
36195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36196   int jresult ;
36197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36198   Dali::DrawMode::Type result;
36199
36200   arg1 = (Dali::Actor *)jarg1;
36201   {
36202     try {
36203       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36204     } catch (std::out_of_range& e) {
36205       {
36206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36207       };
36208     } catch (std::exception& e) {
36209       {
36210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36211       };
36212     } catch (Dali::DaliException e) {
36213       {
36214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36215       };
36216     } catch (...) {
36217       {
36218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36219       };
36220     }
36221   }
36222
36223   jresult = (int)result;
36224   return jresult;
36225 }
36226
36227
36228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36230   bool arg2 ;
36231
36232   arg1 = (Dali::Actor *)jarg1;
36233   arg2 = jarg2 ? true : false;
36234   {
36235     try {
36236       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36237     } catch (std::out_of_range& e) {
36238       {
36239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36240       };
36241     } catch (std::exception& e) {
36242       {
36243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36244       };
36245     } catch (Dali::DaliException e) {
36246       {
36247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36248       };
36249     } catch (...) {
36250       {
36251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36252       };
36253     }
36254   }
36255
36256 }
36257
36258
36259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36260   unsigned int jresult ;
36261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36262   bool result;
36263
36264   arg1 = (Dali::Actor *)jarg1;
36265   {
36266     try {
36267       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36268     } catch (std::out_of_range& e) {
36269       {
36270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36271       };
36272     } catch (std::exception& e) {
36273       {
36274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36275       };
36276     } catch (Dali::DaliException e) {
36277       {
36278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36279       };
36280     } catch (...) {
36281       {
36282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36283       };
36284     }
36285   }
36286
36287   jresult = result;
36288   return jresult;
36289 }
36290
36291
36292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36293   unsigned int jresult ;
36294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36295   float *arg2 = 0 ;
36296   float *arg3 = 0 ;
36297   float arg4 ;
36298   float arg5 ;
36299   bool result;
36300
36301   arg1 = (Dali::Actor *)jarg1;
36302   arg2 = (float *)jarg2;
36303   arg3 = (float *)jarg3;
36304   arg4 = (float)jarg4;
36305   arg5 = (float)jarg5;
36306   {
36307     try {
36308       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36309     } catch (std::out_of_range& e) {
36310       {
36311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36312       };
36313     } catch (std::exception& e) {
36314       {
36315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36316       };
36317     } catch (Dali::DaliException e) {
36318       {
36319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36320       };
36321     } catch (...) {
36322       {
36323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36324       };
36325     }
36326   }
36327
36328   jresult = result;
36329   return jresult;
36330 }
36331
36332
36333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36335   bool arg2 ;
36336
36337   arg1 = (Dali::Actor *)jarg1;
36338   arg2 = jarg2 ? true : false;
36339   {
36340     try {
36341       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36342     } catch (std::out_of_range& e) {
36343       {
36344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36345       };
36346     } catch (std::exception& e) {
36347       {
36348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36349       };
36350     } catch (Dali::DaliException e) {
36351       {
36352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36353       };
36354     } catch (...) {
36355       {
36356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36357       };
36358     }
36359   }
36360
36361 }
36362
36363
36364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36365   unsigned int jresult ;
36366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36367   bool result;
36368
36369   arg1 = (Dali::Actor *)jarg1;
36370   {
36371     try {
36372       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36373     } catch (std::out_of_range& e) {
36374       {
36375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36376       };
36377     } catch (std::exception& e) {
36378       {
36379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36380       };
36381     } catch (Dali::DaliException e) {
36382       {
36383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36384       };
36385     } catch (...) {
36386       {
36387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36388       };
36389     }
36390   }
36391
36392   jresult = result;
36393   return jresult;
36394 }
36395
36396
36397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36398   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36399   bool arg2 ;
36400
36401   arg1 = (Dali::Actor *)jarg1;
36402   arg2 = jarg2 ? true : false;
36403   {
36404     try {
36405       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36406     } catch (std::out_of_range& e) {
36407       {
36408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36409       };
36410     } catch (std::exception& e) {
36411       {
36412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36413       };
36414     } catch (Dali::DaliException e) {
36415       {
36416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36417       };
36418     } catch (...) {
36419       {
36420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36421       };
36422     }
36423   }
36424
36425 }
36426
36427
36428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36429   unsigned int jresult ;
36430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36431   bool result;
36432
36433   arg1 = (Dali::Actor *)jarg1;
36434   {
36435     try {
36436       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36437     } catch (std::out_of_range& e) {
36438       {
36439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36440       };
36441     } catch (std::exception& e) {
36442       {
36443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36444       };
36445     } catch (Dali::DaliException e) {
36446       {
36447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36448       };
36449     } catch (...) {
36450       {
36451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36452       };
36453     }
36454   }
36455
36456   jresult = result;
36457   return jresult;
36458 }
36459
36460
36461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36463   Dali::ResizePolicy::Type arg2 ;
36464   Dali::Dimension::Type arg3 ;
36465
36466   arg1 = (Dali::Actor *)jarg1;
36467   arg2 = (Dali::ResizePolicy::Type)jarg2;
36468   arg3 = (Dali::Dimension::Type)jarg3;
36469   {
36470     try {
36471       (arg1)->SetResizePolicy(arg2,arg3);
36472     } catch (std::out_of_range& e) {
36473       {
36474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36475       };
36476     } catch (std::exception& e) {
36477       {
36478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36479       };
36480     } catch (Dali::DaliException e) {
36481       {
36482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36483       };
36484     } catch (...) {
36485       {
36486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36487       };
36488     }
36489   }
36490
36491 }
36492
36493
36494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36495   int jresult ;
36496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36497   Dali::Dimension::Type arg2 ;
36498   Dali::ResizePolicy::Type result;
36499
36500   arg1 = (Dali::Actor *)jarg1;
36501   arg2 = (Dali::Dimension::Type)jarg2;
36502   {
36503     try {
36504       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36505     } catch (std::out_of_range& e) {
36506       {
36507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36508       };
36509     } catch (std::exception& e) {
36510       {
36511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36512       };
36513     } catch (Dali::DaliException e) {
36514       {
36515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36516       };
36517     } catch (...) {
36518       {
36519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36520       };
36521     }
36522   }
36523
36524   jresult = (int)result;
36525   return jresult;
36526 }
36527
36528
36529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36531   Dali::SizeScalePolicy::Type arg2 ;
36532
36533   arg1 = (Dali::Actor *)jarg1;
36534   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36535   {
36536     try {
36537       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36538     } catch (std::out_of_range& e) {
36539       {
36540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36541       };
36542     } catch (std::exception& e) {
36543       {
36544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36545       };
36546     } catch (Dali::DaliException e) {
36547       {
36548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36549       };
36550     } catch (...) {
36551       {
36552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36553       };
36554     }
36555   }
36556
36557 }
36558
36559
36560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36561   int jresult ;
36562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36563   Dali::SizeScalePolicy::Type result;
36564
36565   arg1 = (Dali::Actor *)jarg1;
36566   {
36567     try {
36568       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36569     } catch (std::out_of_range& e) {
36570       {
36571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36572       };
36573     } catch (std::exception& e) {
36574       {
36575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36576       };
36577     } catch (Dali::DaliException e) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36580       };
36581     } catch (...) {
36582       {
36583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36584       };
36585     }
36586   }
36587
36588   jresult = (int)result;
36589   return jresult;
36590 }
36591
36592
36593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36595   Dali::Vector3 *arg2 = 0 ;
36596
36597   arg1 = (Dali::Actor *)jarg1;
36598   arg2 = (Dali::Vector3 *)jarg2;
36599   if (!arg2) {
36600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36601     return ;
36602   }
36603   {
36604     try {
36605       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36606     } catch (std::out_of_range& e) {
36607       {
36608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36609       };
36610     } catch (std::exception& e) {
36611       {
36612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36613       };
36614     } catch (Dali::DaliException e) {
36615       {
36616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36617       };
36618     } catch (...) {
36619       {
36620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36621       };
36622     }
36623   }
36624
36625 }
36626
36627
36628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36629   void * jresult ;
36630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36631   Dali::Vector3 result;
36632
36633   arg1 = (Dali::Actor *)jarg1;
36634   {
36635     try {
36636       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36644       };
36645     } catch (Dali::DaliException e) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36648       };
36649     } catch (...) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36652       };
36653     }
36654   }
36655
36656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36657   return jresult;
36658 }
36659
36660
36661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36662   float jresult ;
36663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36664   float arg2 ;
36665   float result;
36666
36667   arg1 = (Dali::Actor *)jarg1;
36668   arg2 = (float)jarg2;
36669   {
36670     try {
36671       result = (float)(arg1)->GetHeightForWidth(arg2);
36672     } catch (std::out_of_range& e) {
36673       {
36674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (std::exception& e) {
36677       {
36678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36679       };
36680     } catch (Dali::DaliException e) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36683       };
36684     } catch (...) {
36685       {
36686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36687       };
36688     }
36689   }
36690
36691   jresult = result;
36692   return jresult;
36693 }
36694
36695
36696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36697   float jresult ;
36698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36699   float arg2 ;
36700   float result;
36701
36702   arg1 = (Dali::Actor *)jarg1;
36703   arg2 = (float)jarg2;
36704   {
36705     try {
36706       result = (float)(arg1)->GetWidthForHeight(arg2);
36707     } catch (std::out_of_range& e) {
36708       {
36709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36710       };
36711     } catch (std::exception& e) {
36712       {
36713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36714       };
36715     } catch (Dali::DaliException e) {
36716       {
36717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36718       };
36719     } catch (...) {
36720       {
36721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36722       };
36723     }
36724   }
36725
36726   jresult = result;
36727   return jresult;
36728 }
36729
36730
36731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36732   float jresult ;
36733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36734   Dali::Dimension::Type arg2 ;
36735   float result;
36736
36737   arg1 = (Dali::Actor *)jarg1;
36738   arg2 = (Dali::Dimension::Type)jarg2;
36739   {
36740     try {
36741       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36742     } catch (std::out_of_range& e) {
36743       {
36744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36745       };
36746     } catch (std::exception& e) {
36747       {
36748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36749       };
36750     } catch (Dali::DaliException e) {
36751       {
36752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36753       };
36754     } catch (...) {
36755       {
36756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36757       };
36758     }
36759   }
36760
36761   jresult = result;
36762   return jresult;
36763 }
36764
36765
36766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36768   Dali::Padding *arg2 = 0 ;
36769
36770   arg1 = (Dali::Actor *)jarg1;
36771   arg2 = (Dali::Padding *)jarg2;
36772   if (!arg2) {
36773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36774     return ;
36775   }
36776   {
36777     try {
36778       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36779     } catch (std::out_of_range& e) {
36780       {
36781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36782       };
36783     } catch (std::exception& e) {
36784       {
36785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36786       };
36787     } catch (Dali::DaliException e) {
36788       {
36789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36790       };
36791     } catch (...) {
36792       {
36793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36794       };
36795     }
36796   }
36797
36798 }
36799
36800
36801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36803   Dali::Padding *arg2 = 0 ;
36804
36805   arg1 = (Dali::Actor *)jarg1;
36806   arg2 = (Dali::Padding *)jarg2;
36807   if (!arg2) {
36808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36809     return ;
36810   }
36811   {
36812     try {
36813       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36814     } catch (std::out_of_range& e) {
36815       {
36816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36817       };
36818     } catch (std::exception& e) {
36819       {
36820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36821       };
36822     } catch (Dali::DaliException e) {
36823       {
36824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36825       };
36826     } catch (...) {
36827       {
36828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36829       };
36830     }
36831   }
36832
36833 }
36834
36835
36836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36837   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36838   Dali::Vector2 *arg2 = 0 ;
36839
36840   arg1 = (Dali::Actor *)jarg1;
36841   arg2 = (Dali::Vector2 *)jarg2;
36842   if (!arg2) {
36843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36844     return ;
36845   }
36846   {
36847     try {
36848       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36849     } catch (std::out_of_range& e) {
36850       {
36851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36852       };
36853     } catch (std::exception& e) {
36854       {
36855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36856       };
36857     } catch (Dali::DaliException e) {
36858       {
36859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36860       };
36861     } catch (...) {
36862       {
36863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36864       };
36865     }
36866   }
36867
36868 }
36869
36870
36871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36872   void * jresult ;
36873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36874   Dali::Vector2 result;
36875
36876   arg1 = (Dali::Actor *)jarg1;
36877   {
36878     try {
36879       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36880     } catch (std::out_of_range& e) {
36881       {
36882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36883       };
36884     } catch (std::exception& e) {
36885       {
36886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36887       };
36888     } catch (Dali::DaliException e) {
36889       {
36890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36891       };
36892     } catch (...) {
36893       {
36894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36895       };
36896     }
36897   }
36898
36899   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36900   return jresult;
36901 }
36902
36903
36904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36906   Dali::Vector2 *arg2 = 0 ;
36907
36908   arg1 = (Dali::Actor *)jarg1;
36909   arg2 = (Dali::Vector2 *)jarg2;
36910   if (!arg2) {
36911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36912     return ;
36913   }
36914   {
36915     try {
36916       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36917     } catch (std::out_of_range& e) {
36918       {
36919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36920       };
36921     } catch (std::exception& e) {
36922       {
36923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36924       };
36925     } catch (Dali::DaliException e) {
36926       {
36927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36928       };
36929     } catch (...) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36932       };
36933     }
36934   }
36935
36936 }
36937
36938
36939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36940   void * jresult ;
36941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36942   Dali::Vector2 result;
36943
36944   arg1 = (Dali::Actor *)jarg1;
36945   {
36946     try {
36947       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36948     } catch (std::out_of_range& e) {
36949       {
36950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36951       };
36952     } catch (std::exception& e) {
36953       {
36954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36955       };
36956     } catch (Dali::DaliException e) {
36957       {
36958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36959       };
36960     } catch (...) {
36961       {
36962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36963       };
36964     }
36965   }
36966
36967   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36968   return jresult;
36969 }
36970
36971
36972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36973   int jresult ;
36974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36975   int result;
36976
36977   arg1 = (Dali::Actor *)jarg1;
36978   {
36979     try {
36980       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36981       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36982     } catch (std::out_of_range& e) {
36983       {
36984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36985       };
36986     } catch (std::exception& e) {
36987       {
36988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36989       };
36990     } catch (Dali::DaliException e) {
36991       {
36992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36993       };
36994     } catch (...) {
36995       {
36996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36997       };
36998     }
36999   }
37000
37001   jresult = result;
37002   return jresult;
37003 }
37004
37005
37006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
37007   unsigned int jresult ;
37008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37009   Dali::Renderer *arg2 = 0 ;
37010   unsigned int result;
37011
37012   arg1 = (Dali::Actor *)jarg1;
37013   arg2 = (Dali::Renderer *)jarg2;
37014   if (!arg2) {
37015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
37016     return 0;
37017   }
37018   {
37019     try {
37020       result = (unsigned int)(arg1)->AddRenderer(*arg2);
37021     } catch (std::out_of_range& e) {
37022       {
37023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37024       };
37025     } catch (std::exception& e) {
37026       {
37027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37028       };
37029     } catch (Dali::DaliException e) {
37030       {
37031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37032       };
37033     } catch (...) {
37034       {
37035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37036       };
37037     }
37038   }
37039
37040   jresult = result;
37041   return jresult;
37042 }
37043
37044
37045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
37046   unsigned int jresult ;
37047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37048   unsigned int result;
37049
37050   arg1 = (Dali::Actor *)jarg1;
37051   {
37052     try {
37053       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
37054     } catch (std::out_of_range& e) {
37055       {
37056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37057       };
37058     } catch (std::exception& e) {
37059       {
37060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37061       };
37062     } catch (Dali::DaliException e) {
37063       {
37064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37065       };
37066     } catch (...) {
37067       {
37068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37069       };
37070     }
37071   }
37072
37073   jresult = result;
37074   return jresult;
37075 }
37076
37077
37078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
37079   void * jresult ;
37080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37081   unsigned int arg2 ;
37082   Dali::Renderer result;
37083
37084   arg1 = (Dali::Actor *)jarg1;
37085   arg2 = (unsigned int)jarg2;
37086   {
37087     try {
37088       result = (arg1)->GetRendererAt(arg2);
37089     } catch (std::out_of_range& e) {
37090       {
37091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (std::exception& e) {
37094       {
37095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37096       };
37097     } catch (Dali::DaliException e) {
37098       {
37099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37100       };
37101     } catch (...) {
37102       {
37103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37104       };
37105     }
37106   }
37107
37108   jresult = new Dali::Renderer((const Dali::Renderer &)result);
37109   return jresult;
37110 }
37111
37112
37113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
37114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37115   Dali::Renderer *arg2 = 0 ;
37116
37117   arg1 = (Dali::Actor *)jarg1;
37118   arg2 = (Dali::Renderer *)jarg2;
37119   if (!arg2) {
37120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
37121     return ;
37122   }
37123   {
37124     try {
37125       (arg1)->RemoveRenderer(*arg2);
37126     } catch (std::out_of_range& e) {
37127       {
37128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37129       };
37130     } catch (std::exception& e) {
37131       {
37132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37133       };
37134     } catch (Dali::DaliException e) {
37135       {
37136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37137       };
37138     } catch (...) {
37139       {
37140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37141       };
37142     }
37143   }
37144
37145 }
37146
37147
37148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
37149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37150   unsigned int arg2 ;
37151
37152   arg1 = (Dali::Actor *)jarg1;
37153   arg2 = (unsigned int)jarg2;
37154   {
37155     try {
37156       (arg1)->RemoveRenderer(arg2);
37157     } catch (std::out_of_range& e) {
37158       {
37159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37160       };
37161     } catch (std::exception& e) {
37162       {
37163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37164       };
37165     } catch (Dali::DaliException e) {
37166       {
37167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37168       };
37169     } catch (...) {
37170       {
37171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37172       };
37173     }
37174   }
37175
37176 }
37177
37178
37179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37180   void * jresult ;
37181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37182   Dali::Actor::TouchEventSignalType *result = 0 ;
37183
37184   arg1 = (Dali::Actor *)jarg1;
37185   {
37186     try {
37187       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
37188     } catch (std::out_of_range& e) {
37189       {
37190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37191       };
37192     } catch (std::exception& e) {
37193       {
37194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37195       };
37196     } catch (Dali::DaliException e) {
37197       {
37198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37199       };
37200     } catch (...) {
37201       {
37202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37203       };
37204     }
37205   }
37206
37207   jresult = (void *)result;
37208   return jresult;
37209 }
37210
37211
37212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37213   void * jresult ;
37214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37215   Dali::Actor::HoverSignalType *result = 0 ;
37216
37217   arg1 = (Dali::Actor *)jarg1;
37218   {
37219     try {
37220       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37221     } catch (std::out_of_range& e) {
37222       {
37223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37224       };
37225     } catch (std::exception& e) {
37226       {
37227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37228       };
37229     } catch (Dali::DaliException e) {
37230       {
37231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37232       };
37233     } catch (...) {
37234       {
37235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37236       };
37237     }
37238   }
37239
37240   jresult = (void *)result;
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37246   void * jresult ;
37247   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37248   Dali::Actor::WheelEventSignalType *result = 0 ;
37249
37250   arg1 = (Dali::Actor *)jarg1;
37251   {
37252     try {
37253       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37254     } catch (std::out_of_range& e) {
37255       {
37256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37257       };
37258     } catch (std::exception& e) {
37259       {
37260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37261       };
37262     } catch (Dali::DaliException e) {
37263       {
37264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37265       };
37266     } catch (...) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37269       };
37270     }
37271   }
37272
37273   jresult = (void *)result;
37274   return jresult;
37275 }
37276
37277
37278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
37279   void * jresult ;
37280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37281   Dali::Actor::OnSceneSignalType *result = 0 ;
37282
37283   arg1 = (Dali::Actor *)jarg1;
37284   {
37285     try {
37286       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
37287     } catch (std::out_of_range& e) {
37288       {
37289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37290       };
37291     } catch (std::exception& e) {
37292       {
37293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37294       };
37295     } catch (Dali::DaliException e) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37298       };
37299     } catch (...) {
37300       {
37301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37302       };
37303     }
37304   }
37305
37306   jresult = (void *)result;
37307   return jresult;
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
37312   void * jresult ;
37313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37314   Dali::Actor::OffSceneSignalType *result = 0 ;
37315
37316   arg1 = (Dali::Actor *)jarg1;
37317   {
37318     try {
37319       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
37320     } catch (std::out_of_range& e) {
37321       {
37322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37323       };
37324     } catch (std::exception& e) {
37325       {
37326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37327       };
37328     } catch (Dali::DaliException e) {
37329       {
37330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37331       };
37332     } catch (...) {
37333       {
37334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37335       };
37336     }
37337   }
37338
37339   jresult = (void *)result;
37340   return jresult;
37341 }
37342
37343
37344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37345   void * jresult ;
37346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37347   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37348
37349   arg1 = (Dali::Actor *)jarg1;
37350   {
37351     try {
37352       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37353     } catch (std::out_of_range& e) {
37354       {
37355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37356       };
37357     } catch (std::exception& e) {
37358       {
37359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37360       };
37361     } catch (Dali::DaliException e) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37364       };
37365     } catch (...) {
37366       {
37367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37368       };
37369     }
37370   }
37371
37372   jresult = (void *)result;
37373   return jresult;
37374 }
37375
37376
37377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37378   Dali::Actor *arg1 = 0 ;
37379
37380   arg1 = (Dali::Actor *)jarg1;
37381   if (!arg1) {
37382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37383     return ;
37384   }
37385   {
37386     try {
37387       Dali::UnparentAndReset(*arg1);
37388     } catch (std::out_of_range& e) {
37389       {
37390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37391       };
37392     } catch (std::exception& e) {
37393       {
37394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37395       };
37396     } catch (Dali::DaliException e) {
37397       {
37398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37399       };
37400     } catch (...) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37403       };
37404     }
37405   }
37406
37407 }
37408
37409
37410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37411   int jresult ;
37412   int result;
37413
37414   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37415   jresult = (int)result;
37416   return jresult;
37417 }
37418
37419
37420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37421   int jresult ;
37422   int result;
37423
37424   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37425   jresult = (int)result;
37426   return jresult;
37427 }
37428
37429
37430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37431   int jresult ;
37432   int result;
37433
37434   result = (int)Dali::Layer::Property::BEHAVIOR;
37435   jresult = (int)result;
37436   return jresult;
37437 }
37438
37439
37440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37441   void * jresult ;
37442   Dali::Layer::Property *result = 0 ;
37443
37444   {
37445     try {
37446       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37447     } catch (std::out_of_range& e) {
37448       {
37449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37450       };
37451     } catch (std::exception& e) {
37452       {
37453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37454       };
37455     } catch (Dali::DaliException e) {
37456       {
37457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37458       };
37459     } catch (...) {
37460       {
37461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37462       };
37463     }
37464   }
37465
37466   jresult = (void *)result;
37467   return jresult;
37468 }
37469
37470
37471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37472   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37473
37474   arg1 = (Dali::Layer::Property *)jarg1;
37475   {
37476     try {
37477       delete arg1;
37478     } catch (std::out_of_range& e) {
37479       {
37480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37481       };
37482     } catch (std::exception& e) {
37483       {
37484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37485       };
37486     } catch (Dali::DaliException e) {
37487       {
37488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37489       };
37490     } catch (...) {
37491       {
37492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37493       };
37494     }
37495   }
37496
37497 }
37498
37499
37500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37501   void * jresult ;
37502   Dali::Layer *result = 0 ;
37503
37504   {
37505     try {
37506       result = (Dali::Layer *)new Dali::Layer();
37507     } catch (std::out_of_range& e) {
37508       {
37509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37510       };
37511     } catch (std::exception& e) {
37512       {
37513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37514       };
37515     } catch (Dali::DaliException e) {
37516       {
37517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37518       };
37519     } catch (...) {
37520       {
37521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37522       };
37523     }
37524   }
37525
37526   jresult = (void *)result;
37527   return jresult;
37528 }
37529
37530
37531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37532   void * jresult ;
37533   Dali::Layer result;
37534
37535   {
37536     try {
37537       result = Dali::Layer::New();
37538     } catch (std::out_of_range& e) {
37539       {
37540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37541       };
37542     } catch (std::exception& e) {
37543       {
37544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37545       };
37546     } catch (Dali::DaliException e) {
37547       {
37548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37549       };
37550     } catch (...) {
37551       {
37552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37553       };
37554     }
37555   }
37556
37557   jresult = new Dali::Layer((const Dali::Layer &)result);
37558   return jresult;
37559 }
37560
37561
37562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37563   void * jresult ;
37564   Dali::BaseHandle arg1 ;
37565   Dali::BaseHandle *argp1 ;
37566   Dali::Layer result;
37567
37568   argp1 = (Dali::BaseHandle *)jarg1;
37569   if (!argp1) {
37570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37571     return 0;
37572   }
37573   arg1 = *argp1;
37574   {
37575     try {
37576       result = Dali::Layer::DownCast(arg1);
37577     } catch (std::out_of_range& e) {
37578       {
37579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37580       };
37581     } catch (std::exception& e) {
37582       {
37583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37584       };
37585     } catch (Dali::DaliException e) {
37586       {
37587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37588       };
37589     } catch (...) {
37590       {
37591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37592       };
37593     }
37594   }
37595
37596   jresult = new Dali::Layer((const Dali::Layer &)result);
37597   return jresult;
37598 }
37599
37600
37601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37602   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37603
37604   arg1 = (Dali::Layer *)jarg1;
37605   {
37606     try {
37607       delete arg1;
37608     } catch (std::out_of_range& e) {
37609       {
37610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37611       };
37612     } catch (std::exception& e) {
37613       {
37614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37615       };
37616     } catch (Dali::DaliException e) {
37617       {
37618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37619       };
37620     } catch (...) {
37621       {
37622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37623       };
37624     }
37625   }
37626
37627 }
37628
37629
37630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37631   void * jresult ;
37632   Dali::Layer *arg1 = 0 ;
37633   Dali::Layer *result = 0 ;
37634
37635   arg1 = (Dali::Layer *)jarg1;
37636   if (!arg1) {
37637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37638     return 0;
37639   }
37640   {
37641     try {
37642       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37643     } catch (std::out_of_range& e) {
37644       {
37645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37646       };
37647     } catch (std::exception& e) {
37648       {
37649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37650       };
37651     } catch (Dali::DaliException e) {
37652       {
37653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37654       };
37655     } catch (...) {
37656       {
37657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37658       };
37659     }
37660   }
37661
37662   jresult = (void *)result;
37663   return jresult;
37664 }
37665
37666
37667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37668   void * jresult ;
37669   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37670   Dali::Layer *arg2 = 0 ;
37671   Dali::Layer *result = 0 ;
37672
37673   arg1 = (Dali::Layer *)jarg1;
37674   arg2 = (Dali::Layer *)jarg2;
37675   if (!arg2) {
37676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37677     return 0;
37678   }
37679   {
37680     try {
37681       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37682     } catch (std::out_of_range& e) {
37683       {
37684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37685       };
37686     } catch (std::exception& e) {
37687       {
37688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37689       };
37690     } catch (Dali::DaliException e) {
37691       {
37692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37693       };
37694     } catch (...) {
37695       {
37696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37697       };
37698     }
37699   }
37700
37701   jresult = (void *)result;
37702   return jresult;
37703 }
37704
37705
37706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37707   unsigned int jresult ;
37708   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37709   unsigned int result;
37710
37711   arg1 = (Dali::Layer *)jarg1;
37712   {
37713     try {
37714       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37715     } catch (std::out_of_range& e) {
37716       {
37717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (std::exception& e) {
37720       {
37721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37722       };
37723     } catch (Dali::DaliException e) {
37724       {
37725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37726       };
37727     } catch (...) {
37728       {
37729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37730       };
37731     }
37732   }
37733
37734   jresult = result;
37735   return jresult;
37736 }
37737
37738
37739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37740   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37741
37742   arg1 = (Dali::Layer *)jarg1;
37743   {
37744     try {
37745       (arg1)->Raise();
37746     } catch (std::out_of_range& e) {
37747       {
37748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37749       };
37750     } catch (std::exception& e) {
37751       {
37752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37753       };
37754     } catch (Dali::DaliException e) {
37755       {
37756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37757       };
37758     } catch (...) {
37759       {
37760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37761       };
37762     }
37763   }
37764
37765 }
37766
37767
37768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37769   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37770
37771   arg1 = (Dali::Layer *)jarg1;
37772   {
37773     try {
37774       (arg1)->Lower();
37775     } catch (std::out_of_range& e) {
37776       {
37777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37778       };
37779     } catch (std::exception& e) {
37780       {
37781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37782       };
37783     } catch (Dali::DaliException e) {
37784       {
37785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37786       };
37787     } catch (...) {
37788       {
37789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37790       };
37791     }
37792   }
37793
37794 }
37795
37796
37797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37798   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37799   Dali::Layer arg2 ;
37800   Dali::Layer *argp2 ;
37801
37802   arg1 = (Dali::Layer *)jarg1;
37803   argp2 = (Dali::Layer *)jarg2;
37804   if (!argp2) {
37805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37806     return ;
37807   }
37808   arg2 = *argp2;
37809   {
37810     try {
37811       (arg1)->RaiseAbove(arg2);
37812     } catch (std::out_of_range& e) {
37813       {
37814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37815       };
37816     } catch (std::exception& e) {
37817       {
37818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37819       };
37820     } catch (Dali::DaliException e) {
37821       {
37822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37823       };
37824     } catch (...) {
37825       {
37826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37827       };
37828     }
37829   }
37830
37831 }
37832
37833
37834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37835   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37836   Dali::Layer arg2 ;
37837   Dali::Layer *argp2 ;
37838
37839   arg1 = (Dali::Layer *)jarg1;
37840   argp2 = (Dali::Layer *)jarg2;
37841   if (!argp2) {
37842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37843     return ;
37844   }
37845   arg2 = *argp2;
37846   {
37847     try {
37848       (arg1)->LowerBelow(arg2);
37849     } catch (std::out_of_range& e) {
37850       {
37851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37852       };
37853     } catch (std::exception& e) {
37854       {
37855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37856       };
37857     } catch (Dali::DaliException e) {
37858       {
37859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37860       };
37861     } catch (...) {
37862       {
37863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37864       };
37865     }
37866   }
37867
37868 }
37869
37870
37871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37872   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37873
37874   arg1 = (Dali::Layer *)jarg1;
37875   {
37876     try {
37877       (arg1)->RaiseToTop();
37878     } catch (std::out_of_range& e) {
37879       {
37880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37881       };
37882     } catch (std::exception& e) {
37883       {
37884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37885       };
37886     } catch (Dali::DaliException e) {
37887       {
37888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37889       };
37890     } catch (...) {
37891       {
37892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37893       };
37894     }
37895   }
37896
37897 }
37898
37899
37900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37901   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37902
37903   arg1 = (Dali::Layer *)jarg1;
37904   {
37905     try {
37906       (arg1)->LowerToBottom();
37907     } catch (std::out_of_range& e) {
37908       {
37909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37910       };
37911     } catch (std::exception& e) {
37912       {
37913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37914       };
37915     } catch (Dali::DaliException e) {
37916       {
37917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37918       };
37919     } catch (...) {
37920       {
37921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37922       };
37923     }
37924   }
37925
37926 }
37927
37928
37929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37930   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37931   Dali::Layer arg2 ;
37932   Dali::Layer *argp2 ;
37933
37934   arg1 = (Dali::Layer *)jarg1;
37935   argp2 = (Dali::Layer *)jarg2;
37936   if (!argp2) {
37937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37938     return ;
37939   }
37940   arg2 = *argp2;
37941   {
37942     try {
37943       (arg1)->MoveAbove(arg2);
37944     } catch (std::out_of_range& e) {
37945       {
37946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37947       };
37948     } catch (std::exception& e) {
37949       {
37950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37951       };
37952     } catch (Dali::DaliException e) {
37953       {
37954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37955       };
37956     } catch (...) {
37957       {
37958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37959       };
37960     }
37961   }
37962
37963 }
37964
37965
37966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37967   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37968   Dali::Layer arg2 ;
37969   Dali::Layer *argp2 ;
37970
37971   arg1 = (Dali::Layer *)jarg1;
37972   argp2 = (Dali::Layer *)jarg2;
37973   if (!argp2) {
37974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37975     return ;
37976   }
37977   arg2 = *argp2;
37978   {
37979     try {
37980       (arg1)->MoveBelow(arg2);
37981     } catch (std::out_of_range& e) {
37982       {
37983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37984       };
37985     } catch (std::exception& e) {
37986       {
37987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37988       };
37989     } catch (Dali::DaliException e) {
37990       {
37991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37992       };
37993     } catch (...) {
37994       {
37995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37996       };
37997     }
37998   }
37999
38000 }
38001
38002
38003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
38004   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38005   Dali::Layer::Behavior arg2 ;
38006
38007   arg1 = (Dali::Layer *)jarg1;
38008   arg2 = (Dali::Layer::Behavior)jarg2;
38009   {
38010     try {
38011       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
38012     } catch (std::out_of_range& e) {
38013       {
38014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38015       };
38016     } catch (std::exception& e) {
38017       {
38018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38019       };
38020     } catch (Dali::DaliException e) {
38021       {
38022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38023       };
38024     } catch (...) {
38025       {
38026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38027       };
38028     }
38029   }
38030
38031 }
38032
38033
38034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
38035   int jresult ;
38036   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38037   Dali::Layer::Behavior result;
38038
38039   arg1 = (Dali::Layer *)jarg1;
38040   {
38041     try {
38042       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
38043     } catch (std::out_of_range& e) {
38044       {
38045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38046       };
38047     } catch (std::exception& e) {
38048       {
38049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38050       };
38051     } catch (Dali::DaliException e) {
38052       {
38053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38054       };
38055     } catch (...) {
38056       {
38057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38058       };
38059     }
38060   }
38061
38062   jresult = (int)result;
38063   return jresult;
38064 }
38065
38066
38067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
38068   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38069   bool arg2 ;
38070
38071   arg1 = (Dali::Layer *)jarg1;
38072   arg2 = jarg2 ? true : false;
38073   {
38074     try {
38075       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
38076     } catch (std::out_of_range& e) {
38077       {
38078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38079       };
38080     } catch (std::exception& e) {
38081       {
38082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38083       };
38084     } catch (Dali::DaliException e) {
38085       {
38086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38087       };
38088     } catch (...) {
38089       {
38090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38091       };
38092     }
38093   }
38094
38095 }
38096
38097
38098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
38099   unsigned int jresult ;
38100   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38101   bool result;
38102
38103   arg1 = (Dali::Layer *)jarg1;
38104   {
38105     try {
38106       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
38107     } catch (std::out_of_range& e) {
38108       {
38109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38110       };
38111     } catch (std::exception& e) {
38112       {
38113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38114       };
38115     } catch (Dali::DaliException e) {
38116       {
38117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38118       };
38119     } catch (...) {
38120       {
38121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38122       };
38123     }
38124   }
38125
38126   jresult = result;
38127   return jresult;
38128 }
38129
38130
38131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38132   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38133   int arg2 ;
38134   int arg3 ;
38135   int arg4 ;
38136   int arg5 ;
38137
38138   arg1 = (Dali::Layer *)jarg1;
38139   arg2 = (int)jarg2;
38140   arg3 = (int)jarg3;
38141   arg4 = (int)jarg4;
38142   arg5 = (int)jarg5;
38143   {
38144     try {
38145       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
38146     } catch (std::out_of_range& e) {
38147       {
38148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38149       };
38150     } catch (std::exception& e) {
38151       {
38152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38153       };
38154     } catch (Dali::DaliException e) {
38155       {
38156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38157       };
38158     } catch (...) {
38159       {
38160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38161       };
38162     }
38163   }
38164
38165 }
38166
38167
38168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38169   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38170   Dali::ClippingBox arg2 ;
38171   Dali::ClippingBox *argp2 ;
38172
38173   arg1 = (Dali::Layer *)jarg1;
38174   argp2 = (Dali::ClippingBox *)jarg2;
38175   if (!argp2) {
38176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38177     return ;
38178   }
38179   arg2 = *argp2;
38180   {
38181     try {
38182       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
38183     } catch (std::out_of_range& e) {
38184       {
38185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38186       };
38187     } catch (std::exception& e) {
38188       {
38189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38190       };
38191     } catch (Dali::DaliException e) {
38192       {
38193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38194       };
38195     } catch (...) {
38196       {
38197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38198       };
38199     }
38200   }
38201
38202 }
38203
38204
38205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38206   void * jresult ;
38207   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38208   Dali::ClippingBox result;
38209
38210   arg1 = (Dali::Layer *)jarg1;
38211   {
38212     try {
38213       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
38214     } catch (std::out_of_range& e) {
38215       {
38216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38217       };
38218     } catch (std::exception& e) {
38219       {
38220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38221       };
38222     } catch (Dali::DaliException e) {
38223       {
38224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38225       };
38226     } catch (...) {
38227       {
38228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38229       };
38230     }
38231   }
38232
38233   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38234   return jresult;
38235 }
38236
38237
38238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38239   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38240   bool arg2 ;
38241
38242   arg1 = (Dali::Layer *)jarg1;
38243   arg2 = jarg2 ? true : false;
38244   {
38245     try {
38246       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
38247     } catch (std::out_of_range& e) {
38248       {
38249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38250       };
38251     } catch (std::exception& e) {
38252       {
38253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38254       };
38255     } catch (Dali::DaliException e) {
38256       {
38257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38258       };
38259     } catch (...) {
38260       {
38261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38262       };
38263     }
38264   }
38265
38266 }
38267
38268
38269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38270   unsigned int jresult ;
38271   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38272   bool result;
38273
38274   arg1 = (Dali::Layer *)jarg1;
38275   {
38276     try {
38277       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
38278     } catch (std::out_of_range& e) {
38279       {
38280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38281       };
38282     } catch (std::exception& e) {
38283       {
38284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38285       };
38286     } catch (Dali::DaliException e) {
38287       {
38288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38289       };
38290     } catch (...) {
38291       {
38292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38293       };
38294     }
38295   }
38296
38297   jresult = result;
38298   return jresult;
38299 }
38300
38301
38302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38303   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38304   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38305
38306   arg1 = (Dali::Layer *)jarg1;
38307   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38308   {
38309     try {
38310       (arg1)->SetSortFunction(arg2);
38311     } catch (std::out_of_range& e) {
38312       {
38313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38314       };
38315     } catch (std::exception& e) {
38316       {
38317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38318       };
38319     } catch (Dali::DaliException e) {
38320       {
38321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38322       };
38323     } catch (...) {
38324       {
38325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38326       };
38327     }
38328   }
38329
38330 }
38331
38332
38333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38334   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38335   bool arg2 ;
38336
38337   arg1 = (Dali::Layer *)jarg1;
38338   arg2 = jarg2 ? true : false;
38339   {
38340     try {
38341       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38342     } catch (std::out_of_range& e) {
38343       {
38344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38345       };
38346     } catch (std::exception& e) {
38347       {
38348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38349       };
38350     } catch (Dali::DaliException e) {
38351       {
38352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38357       };
38358     }
38359   }
38360
38361 }
38362
38363
38364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38365   unsigned int jresult ;
38366   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38367   bool result;
38368
38369   arg1 = (Dali::Layer *)jarg1;
38370   {
38371     try {
38372       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38373     } catch (std::out_of_range& e) {
38374       {
38375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38376       };
38377     } catch (std::exception& e) {
38378       {
38379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38380       };
38381     } catch (Dali::DaliException e) {
38382       {
38383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38384       };
38385     } catch (...) {
38386       {
38387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38388       };
38389     }
38390   }
38391
38392   jresult = result;
38393   return jresult;
38394 }
38395
38396
38397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38398   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38399   bool arg2 ;
38400
38401   arg1 = (Dali::Layer *)jarg1;
38402   arg2 = jarg2 ? true : false;
38403   {
38404     try {
38405       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38406     } catch (std::out_of_range& e) {
38407       {
38408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38409       };
38410     } catch (std::exception& e) {
38411       {
38412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38413       };
38414     } catch (Dali::DaliException e) {
38415       {
38416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38417       };
38418     } catch (...) {
38419       {
38420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38421       };
38422     }
38423   }
38424
38425 }
38426
38427
38428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38429   unsigned int jresult ;
38430   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38431   bool result;
38432
38433   arg1 = (Dali::Layer *)jarg1;
38434   {
38435     try {
38436       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38437     } catch (std::out_of_range& e) {
38438       {
38439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38440       };
38441     } catch (std::exception& e) {
38442       {
38443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38444       };
38445     } catch (Dali::DaliException e) {
38446       {
38447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38448       };
38449     } catch (...) {
38450       {
38451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38452       };
38453     }
38454   }
38455
38456   jresult = result;
38457   return jresult;
38458 }
38459
38460
38461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38462   void * jresult ;
38463   Dali::Stage result;
38464
38465   {
38466     try {
38467       result = Dali::Stage::GetCurrent();
38468     } catch (std::out_of_range& e) {
38469       {
38470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38471       };
38472     } catch (std::exception& e) {
38473       {
38474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38475       };
38476     } catch (Dali::DaliException e) {
38477       {
38478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38479       };
38480     } catch (...) {
38481       {
38482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38483       };
38484     }
38485   }
38486
38487   jresult = new Dali::Stage((const Dali::Stage &)result);
38488   return jresult;
38489 }
38490
38491
38492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38493   unsigned int jresult ;
38494   bool result;
38495
38496   {
38497     try {
38498       result = (bool)Dali::Stage::IsInstalled();
38499     } catch (std::out_of_range& e) {
38500       {
38501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38502       };
38503     } catch (std::exception& e) {
38504       {
38505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38506       };
38507     } catch (Dali::DaliException e) {
38508       {
38509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38510       };
38511     } catch (...) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38514       };
38515     }
38516   }
38517
38518   jresult = result;
38519   return jresult;
38520 }
38521
38522
38523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38524   void * jresult ;
38525   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38526   Dali::Vector2 result;
38527
38528   arg1 = (Dali::Stage *)jarg1;
38529   {
38530     try {
38531       result = ((Dali::Stage const *)arg1)->GetDpi();
38532     } catch (std::out_of_range& e) {
38533       {
38534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38535       };
38536     } catch (std::exception& e) {
38537       {
38538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38539       };
38540     } catch (Dali::DaliException e) {
38541       {
38542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38543       };
38544     } catch (...) {
38545       {
38546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38547       };
38548     }
38549   }
38550
38551   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38552   return jresult;
38553 }
38554
38555
38556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38557   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38558   float arg2 ;
38559
38560   arg1 = (Dali::Stage *)jarg1;
38561   arg2 = (float)jarg2;
38562   {
38563     try {
38564       (arg1)->KeepRendering(arg2);
38565     } catch (std::out_of_range& e) {
38566       {
38567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38568       };
38569     } catch (std::exception& e) {
38570       {
38571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38572       };
38573     } catch (Dali::DaliException e) {
38574       {
38575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38580       };
38581     }
38582   }
38583
38584 }
38585
38586
38587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38588   void * jresult ;
38589   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38590   Dali::Stage::KeyEventSignalType *result = 0 ;
38591
38592   arg1 = (Dali::Stage *)jarg1;
38593   {
38594     try {
38595       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38596     } catch (std::out_of_range& e) {
38597       {
38598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38599       };
38600     } catch (std::exception& e) {
38601       {
38602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38603       };
38604     } catch (Dali::DaliException e) {
38605       {
38606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38607       };
38608     } catch (...) {
38609       {
38610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38611       };
38612     }
38613   }
38614
38615   jresult = (void *)result;
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38621   void * jresult ;
38622   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38623   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38624
38625   arg1 = (Dali::Stage *)jarg1;
38626   {
38627     try {
38628       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38636       };
38637     } catch (Dali::DaliException e) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38640       };
38641     } catch (...) {
38642       {
38643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38644       };
38645     }
38646   }
38647
38648   jresult = (void *)result;
38649   return jresult;
38650 }
38651
38652
38653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38654   void * jresult ;
38655   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38656   Dali::Stage::TouchSignalType *result = 0 ;
38657
38658   arg1 = (Dali::Stage *)jarg1;
38659   {
38660     try {
38661       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38662     } catch (std::out_of_range& e) {
38663       {
38664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (std::exception& e) {
38667       {
38668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38669       };
38670     } catch (Dali::DaliException e) {
38671       {
38672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38673       };
38674     } catch (...) {
38675       {
38676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38677       };
38678     }
38679   }
38680
38681   jresult = (void *)result;
38682   return jresult;
38683 }
38684
38685
38686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38687   void * jresult ;
38688   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38689   Dali::Stage::WheelEventSignalType *result = 0 ;
38690
38691   arg1 = (Dali::Stage *)jarg1;
38692   {
38693     try {
38694       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38695     } catch (std::out_of_range& e) {
38696       {
38697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (std::exception& e) {
38700       {
38701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38702       };
38703     } catch (Dali::DaliException e) {
38704       {
38705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38706       };
38707     } catch (...) {
38708       {
38709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38710       };
38711     }
38712   }
38713
38714   jresult = (void *)result;
38715   return jresult;
38716 }
38717
38718
38719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38720   void * jresult ;
38721   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38722   Dali::Stage::ContextStatusSignal *result = 0 ;
38723
38724   arg1 = (Dali::Stage *)jarg1;
38725   {
38726     try {
38727       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38728     } catch (std::out_of_range& e) {
38729       {
38730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38731       };
38732     } catch (std::exception& e) {
38733       {
38734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38735       };
38736     } catch (Dali::DaliException e) {
38737       {
38738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38739       };
38740     } catch (...) {
38741       {
38742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38743       };
38744     }
38745   }
38746
38747   jresult = (void *)result;
38748   return jresult;
38749 }
38750
38751
38752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38753   void * jresult ;
38754   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38755   Dali::Stage::ContextStatusSignal *result = 0 ;
38756
38757   arg1 = (Dali::Stage *)jarg1;
38758   {
38759     try {
38760       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38761     } catch (std::out_of_range& e) {
38762       {
38763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38764       };
38765     } catch (std::exception& e) {
38766       {
38767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38768       };
38769     } catch (Dali::DaliException e) {
38770       {
38771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38772       };
38773     } catch (...) {
38774       {
38775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38776       };
38777     }
38778   }
38779
38780   jresult = (void *)result;
38781   return jresult;
38782 }
38783
38784
38785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38786   void * jresult ;
38787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38788   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38789
38790   arg1 = (Dali::Stage *)jarg1;
38791   {
38792     try {
38793       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38794     } catch (std::out_of_range& e) {
38795       {
38796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38797       };
38798     } catch (std::exception& e) {
38799       {
38800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38801       };
38802     } catch (Dali::DaliException e) {
38803       {
38804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38805       };
38806     } catch (...) {
38807       {
38808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38809       };
38810     }
38811   }
38812
38813   jresult = (void *)result;
38814   return jresult;
38815 }
38816
38817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38818   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38819   Dali::DevelStage::Rendering arg2 ;
38820
38821   arg1 = (Dali::Stage *)jarg1;
38822   arg2 = (Dali::DevelStage::Rendering)jarg2;
38823   {
38824     try {
38825       DevelStage::SetRenderingBehavior(*arg1,arg2);
38826     } catch (std::out_of_range& e) {
38827       {
38828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38829       };
38830     } catch (std::exception& e) {
38831       {
38832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38833       };
38834     } catch (Dali::DaliException e) {
38835       {
38836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38837       };
38838     } catch (...) {
38839       {
38840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38841       };
38842     }
38843   }
38844
38845 }
38846
38847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38848
38849   int jresult ;
38850   int result ;
38851   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38852
38853   arg1 = (Dali::Stage *)jarg1;
38854   {
38855     try {
38856       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38857     } catch (std::out_of_range& e) {
38858       {
38859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (std::exception& e) {
38862       {
38863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38864       };
38865     } catch (Dali::DaliException e) {
38866       {
38867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38868       };
38869     } catch (...) {
38870       {
38871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38872       };
38873     }
38874   }
38875
38876   jresult = result;
38877   return jresult;
38878 }
38879
38880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38881   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38882
38883   arg1 = (Dali::RelayoutContainer *)jarg1;
38884   {
38885     try {
38886       delete arg1;
38887     } catch (std::out_of_range& e) {
38888       {
38889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38890       };
38891     } catch (std::exception& e) {
38892       {
38893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38894       };
38895     } catch (Dali::DaliException e) {
38896       {
38897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38902       };
38903     }
38904   }
38905
38906 }
38907
38908
38909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38910   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38911   Dali::Actor *arg2 = 0 ;
38912   Dali::Vector2 *arg3 = 0 ;
38913
38914   arg1 = (Dali::RelayoutContainer *)jarg1;
38915   arg2 = (Dali::Actor *)jarg2;
38916   if (!arg2) {
38917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38918     return ;
38919   }
38920   arg3 = (Dali::Vector2 *)jarg3;
38921   if (!arg3) {
38922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38923     return ;
38924   }
38925   {
38926     try {
38927       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38928     } catch (std::out_of_range& e) {
38929       {
38930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38931       };
38932     } catch (std::exception& e) {
38933       {
38934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38935       };
38936     } catch (Dali::DaliException e) {
38937       {
38938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38939       };
38940     } catch (...) {
38941       {
38942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38943       };
38944     }
38945   }
38946
38947 }
38948
38949
38950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38951   void * jresult ;
38952   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38953   Dali::CustomActor result;
38954
38955   arg1 = (Dali::CustomActorImpl *)jarg1;
38956   {
38957     try {
38958       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38959     } catch (std::out_of_range& e) {
38960       {
38961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38962       };
38963     } catch (std::exception& e) {
38964       {
38965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38966       };
38967     } catch (Dali::DaliException e) {
38968       {
38969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38970       };
38971     } catch (...) {
38972       {
38973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38974       };
38975     }
38976   }
38977
38978   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38979   return jresult;
38980 }
38981
38982
38983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38984   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38985   int arg2 ;
38986
38987   arg1 = (Dali::CustomActorImpl *)jarg1;
38988   arg2 = (int)jarg2;
38989   {
38990     try {
38991       (arg1)->OnSceneConnection(arg2);
38992     } catch (std::out_of_range& e) {
38993       {
38994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38995       };
38996     } catch (std::exception& e) {
38997       {
38998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38999       };
39000     } catch (Dali::DaliException e) {
39001       {
39002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39003       };
39004     } catch (...) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39007       };
39008     }
39009   }
39010
39011 }
39012
39013
39014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
39015   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39016
39017   arg1 = (Dali::CustomActorImpl *)jarg1;
39018   {
39019     try {
39020       (arg1)->OnSceneDisconnection();
39021     } catch (std::out_of_range& e) {
39022       {
39023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39024       };
39025     } catch (std::exception& e) {
39026       {
39027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (Dali::DaliException e) {
39030       {
39031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39036       };
39037     }
39038   }
39039
39040 }
39041
39042
39043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39044   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39045   Dali::Actor *arg2 = 0 ;
39046
39047   arg1 = (Dali::CustomActorImpl *)jarg1;
39048   arg2 = (Dali::Actor *)jarg2;
39049   if (!arg2) {
39050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39051     return ;
39052   }
39053   {
39054     try {
39055       (arg1)->OnChildAdd(*arg2);
39056     } catch (std::out_of_range& e) {
39057       {
39058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39059       };
39060     } catch (std::exception& e) {
39061       {
39062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39063       };
39064     } catch (Dali::DaliException e) {
39065       {
39066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39067       };
39068     } catch (...) {
39069       {
39070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39071       };
39072     }
39073   }
39074
39075 }
39076
39077
39078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39079   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39080   Dali::Actor *arg2 = 0 ;
39081
39082   arg1 = (Dali::CustomActorImpl *)jarg1;
39083   arg2 = (Dali::Actor *)jarg2;
39084   if (!arg2) {
39085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39086     return ;
39087   }
39088   {
39089     try {
39090       (arg1)->OnChildRemove(*arg2);
39091     } catch (std::out_of_range& e) {
39092       {
39093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39094       };
39095     } catch (std::exception& e) {
39096       {
39097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39098       };
39099     } catch (Dali::DaliException e) {
39100       {
39101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39102       };
39103     } catch (...) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39106       };
39107     }
39108   }
39109
39110 }
39111
39112
39113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39114   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39115   Dali::Property::Index arg2 ;
39116   Dali::Property::Value arg3 ;
39117   Dali::Property::Value *argp3 ;
39118
39119   arg1 = (Dali::CustomActorImpl *)jarg1;
39120   arg2 = (Dali::Property::Index)jarg2;
39121   argp3 = (Dali::Property::Value *)jarg3;
39122   if (!argp3) {
39123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39124     return ;
39125   }
39126   arg3 = *argp3;
39127   {
39128     try {
39129       (arg1)->OnPropertySet(arg2,arg3);
39130     } catch (std::out_of_range& e) {
39131       {
39132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39133       };
39134     } catch (std::exception& e) {
39135       {
39136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39137       };
39138     } catch (Dali::DaliException e) {
39139       {
39140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39141       };
39142     } catch (...) {
39143       {
39144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39145       };
39146     }
39147   }
39148
39149 }
39150
39151
39152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39153   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39154   Dali::Vector3 *arg2 = 0 ;
39155
39156   arg1 = (Dali::CustomActorImpl *)jarg1;
39157   arg2 = (Dali::Vector3 *)jarg2;
39158   if (!arg2) {
39159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39160     return ;
39161   }
39162   {
39163     try {
39164       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39165     } catch (std::out_of_range& e) {
39166       {
39167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39168       };
39169     } catch (std::exception& e) {
39170       {
39171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39172       };
39173     } catch (Dali::DaliException e) {
39174       {
39175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39176       };
39177     } catch (...) {
39178       {
39179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39180       };
39181     }
39182   }
39183
39184 }
39185
39186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39187   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39188   Dali::Animation *arg2 = 0 ;
39189   Dali::Vector3 *arg3 = 0 ;
39190
39191   arg1 = (Dali::CustomActorImpl *)jarg1;
39192   arg2 = (Dali::Animation *)jarg2;
39193   if (!arg2) {
39194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39195     return ;
39196   }
39197   arg3 = (Dali::Vector3 *)jarg3;
39198   if (!arg3) {
39199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39200     return ;
39201   }
39202   {
39203     try {
39204       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39205     } catch (std::out_of_range& e) {
39206       {
39207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39208       };
39209     } catch (std::exception& e) {
39210       {
39211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (Dali::DaliException e) {
39214       {
39215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39216       };
39217     } catch (...) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39220       };
39221     }
39222   }
39223 }
39224
39225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39226   unsigned int jresult ;
39227   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39228   Dali::HoverEvent *arg2 = 0 ;
39229   bool result;
39230
39231   arg1 = (Dali::CustomActorImpl *)jarg1;
39232   arg2 = (Dali::HoverEvent *)jarg2;
39233   if (!arg2) {
39234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39235     return 0;
39236   }
39237   {
39238     try {
39239       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39240     } catch (std::out_of_range& e) {
39241       {
39242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39243       };
39244     } catch (std::exception& e) {
39245       {
39246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39247       };
39248     } catch (Dali::DaliException e) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39251       };
39252     } catch (...) {
39253       {
39254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39255       };
39256     }
39257   }
39258
39259   jresult = result;
39260   return jresult;
39261 }
39262
39263
39264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39265   unsigned int jresult ;
39266   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39267   Dali::KeyEvent *arg2 = 0 ;
39268   bool result;
39269
39270   arg1 = (Dali::CustomActorImpl *)jarg1;
39271   arg2 = (Dali::KeyEvent *)jarg2;
39272   if (!arg2) {
39273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39274     return 0;
39275   }
39276   {
39277     try {
39278       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39279     } catch (std::out_of_range& e) {
39280       {
39281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39282       };
39283     } catch (std::exception& e) {
39284       {
39285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39286       };
39287     } catch (Dali::DaliException e) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39290       };
39291     } catch (...) {
39292       {
39293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39294       };
39295     }
39296   }
39297
39298   jresult = result;
39299   return jresult;
39300 }
39301
39302
39303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39304   unsigned int jresult ;
39305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39306   Dali::WheelEvent *arg2 = 0 ;
39307   bool result;
39308
39309   arg1 = (Dali::CustomActorImpl *)jarg1;
39310   arg2 = (Dali::WheelEvent *)jarg2;
39311   if (!arg2) {
39312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39313     return 0;
39314   }
39315   {
39316     try {
39317       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39318     } catch (std::out_of_range& e) {
39319       {
39320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (std::exception& e) {
39323       {
39324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39325       };
39326     } catch (Dali::DaliException e) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39329       };
39330     } catch (...) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39333       };
39334     }
39335   }
39336
39337   jresult = result;
39338   return jresult;
39339 }
39340
39341
39342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39344   Dali::Vector2 *arg2 = 0 ;
39345   Dali::RelayoutContainer *arg3 = 0 ;
39346
39347   arg1 = (Dali::CustomActorImpl *)jarg1;
39348   arg2 = (Dali::Vector2 *)jarg2;
39349   if (!arg2) {
39350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39351     return ;
39352   }
39353   arg3 = (Dali::RelayoutContainer *)jarg3;
39354   if (!arg3) {
39355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39356     return ;
39357   }
39358   {
39359     try {
39360       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39361     } catch (std::out_of_range& e) {
39362       {
39363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39364       };
39365     } catch (std::exception& e) {
39366       {
39367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39368       };
39369     } catch (Dali::DaliException e) {
39370       {
39371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39372       };
39373     } catch (...) {
39374       {
39375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39376       };
39377     }
39378   }
39379
39380 }
39381
39382
39383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39384   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39385   Dali::ResizePolicy::Type arg2 ;
39386   Dali::Dimension::Type arg3 ;
39387
39388   arg1 = (Dali::CustomActorImpl *)jarg1;
39389   arg2 = (Dali::ResizePolicy::Type)jarg2;
39390   arg3 = (Dali::Dimension::Type)jarg3;
39391   {
39392     try {
39393       (arg1)->OnSetResizePolicy(arg2,arg3);
39394     } catch (std::out_of_range& e) {
39395       {
39396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39397       };
39398     } catch (std::exception& e) {
39399       {
39400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39401       };
39402     } catch (Dali::DaliException e) {
39403       {
39404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39405       };
39406     } catch (...) {
39407       {
39408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39409       };
39410     }
39411   }
39412
39413 }
39414
39415
39416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39417   void * jresult ;
39418   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39419   Dali::Vector3 result;
39420
39421   arg1 = (Dali::CustomActorImpl *)jarg1;
39422   {
39423     try {
39424       result = (arg1)->GetNaturalSize();
39425     } catch (std::out_of_range& e) {
39426       {
39427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39428       };
39429     } catch (std::exception& e) {
39430       {
39431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39432       };
39433     } catch (Dali::DaliException e) {
39434       {
39435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39436       };
39437     } catch (...) {
39438       {
39439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39440       };
39441     }
39442   }
39443
39444   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39445   return jresult;
39446 }
39447
39448
39449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39450   float jresult ;
39451   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39452   Dali::Actor *arg2 = 0 ;
39453   Dali::Dimension::Type arg3 ;
39454   float result;
39455
39456   arg1 = (Dali::CustomActorImpl *)jarg1;
39457   arg2 = (Dali::Actor *)jarg2;
39458   if (!arg2) {
39459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39460     return 0;
39461   }
39462   arg3 = (Dali::Dimension::Type)jarg3;
39463   {
39464     try {
39465       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39466     } catch (std::out_of_range& e) {
39467       {
39468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39469       };
39470     } catch (std::exception& e) {
39471       {
39472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39473       };
39474     } catch (Dali::DaliException e) {
39475       {
39476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39477       };
39478     } catch (...) {
39479       {
39480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39481       };
39482     }
39483   }
39484
39485   jresult = result;
39486   return jresult;
39487 }
39488
39489
39490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39491   float jresult ;
39492   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39493   float arg2 ;
39494   float result;
39495
39496   arg1 = (Dali::CustomActorImpl *)jarg1;
39497   arg2 = (float)jarg2;
39498   {
39499     try {
39500       result = (float)(arg1)->GetHeightForWidth(arg2);
39501     } catch (std::out_of_range& e) {
39502       {
39503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39504       };
39505     } catch (std::exception& e) {
39506       {
39507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39508       };
39509     } catch (Dali::DaliException e) {
39510       {
39511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39512       };
39513     } catch (...) {
39514       {
39515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39516       };
39517     }
39518   }
39519
39520   jresult = result;
39521   return jresult;
39522 }
39523
39524
39525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39526   float jresult ;
39527   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39528   float arg2 ;
39529   float result;
39530
39531   arg1 = (Dali::CustomActorImpl *)jarg1;
39532   arg2 = (float)jarg2;
39533   {
39534     try {
39535       result = (float)(arg1)->GetWidthForHeight(arg2);
39536     } catch (std::out_of_range& e) {
39537       {
39538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39539       };
39540     } catch (std::exception& e) {
39541       {
39542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39543       };
39544     } catch (Dali::DaliException e) {
39545       {
39546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39547       };
39548     } catch (...) {
39549       {
39550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39551       };
39552     }
39553   }
39554
39555   jresult = result;
39556   return jresult;
39557 }
39558
39559
39560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39561   unsigned int jresult ;
39562   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39563   Dali::Dimension::Type arg2 ;
39564   bool result;
39565
39566   arg1 = (Dali::CustomActorImpl *)jarg1;
39567   arg2 = (Dali::Dimension::Type)jarg2;
39568   {
39569     try {
39570       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39571     } catch (std::out_of_range& e) {
39572       {
39573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39574       };
39575     } catch (std::exception& e) {
39576       {
39577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39578       };
39579     } catch (Dali::DaliException e) {
39580       {
39581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39582       };
39583     } catch (...) {
39584       {
39585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39586       };
39587     }
39588   }
39589
39590   jresult = result;
39591   return jresult;
39592 }
39593
39594
39595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39596   unsigned int jresult ;
39597   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39598   bool result;
39599
39600   arg1 = (Dali::CustomActorImpl *)jarg1;
39601   {
39602     try {
39603       result = (bool)(arg1)->RelayoutDependentOnChildren();
39604     } catch (std::out_of_range& e) {
39605       {
39606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39607       };
39608     } catch (std::exception& e) {
39609       {
39610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39611       };
39612     } catch (Dali::DaliException e) {
39613       {
39614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39615       };
39616     } catch (...) {
39617       {
39618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39619       };
39620     }
39621   }
39622
39623   jresult = result;
39624   return jresult;
39625 }
39626
39627
39628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39629   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39630   Dali::Dimension::Type arg2 ;
39631
39632   arg1 = (Dali::CustomActorImpl *)jarg1;
39633   arg2 = (Dali::Dimension::Type)jarg2;
39634   {
39635     try {
39636       (arg1)->OnCalculateRelayoutSize(arg2);
39637     } catch (std::out_of_range& e) {
39638       {
39639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39640       };
39641     } catch (std::exception& e) {
39642       {
39643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39644       };
39645     } catch (Dali::DaliException e) {
39646       {
39647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39648       };
39649     } catch (...) {
39650       {
39651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39652       };
39653     }
39654   }
39655
39656 }
39657
39658
39659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39660   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39661   float arg2 ;
39662   Dali::Dimension::Type arg3 ;
39663
39664   arg1 = (Dali::CustomActorImpl *)jarg1;
39665   arg2 = (float)jarg2;
39666   arg3 = (Dali::Dimension::Type)jarg3;
39667   {
39668     try {
39669       (arg1)->OnLayoutNegotiated(arg2,arg3);
39670     } catch (std::out_of_range& e) {
39671       {
39672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39673       };
39674     } catch (std::exception& e) {
39675       {
39676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39677       };
39678     } catch (Dali::DaliException e) {
39679       {
39680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39681       };
39682     } catch (...) {
39683       {
39684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39685       };
39686     }
39687   }
39688
39689 }
39690
39691
39692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39693   unsigned int jresult ;
39694   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39695   bool result;
39696
39697   arg1 = (Dali::CustomActorImpl *)jarg1;
39698   {
39699     try {
39700       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39701     } catch (std::out_of_range& e) {
39702       {
39703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39704       };
39705     } catch (std::exception& e) {
39706       {
39707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39708       };
39709     } catch (Dali::DaliException e) {
39710       {
39711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39712       };
39713     } catch (...) {
39714       {
39715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39716       };
39717     }
39718   }
39719
39720   jresult = result;
39721   return jresult;
39722 }
39723
39724
39725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39726   unsigned int jresult ;
39727   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39728   bool result;
39729
39730   arg1 = (Dali::CustomActorImpl *)jarg1;
39731   {
39732     try {
39733       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39734     } catch (std::out_of_range& e) {
39735       {
39736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39737       };
39738     } catch (std::exception& e) {
39739       {
39740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39741       };
39742     } catch (Dali::DaliException e) {
39743       {
39744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39745       };
39746     } catch (...) {
39747       {
39748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39749       };
39750     }
39751   }
39752
39753   jresult = result;
39754   return jresult;
39755 }
39756
39757
39758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39759   unsigned int jresult ;
39760   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39761   bool result;
39762
39763   arg1 = (Dali::CustomActorImpl *)jarg1;
39764   {
39765     try {
39766       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39767     } catch (std::out_of_range& e) {
39768       {
39769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (std::exception& e) {
39772       {
39773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (Dali::DaliException e) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39778       };
39779     } catch (...) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39782       };
39783     }
39784   }
39785
39786   jresult = result;
39787   return jresult;
39788 }
39789
39790
39791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39792   unsigned int jresult ;
39793   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39794   bool result;
39795
39796   arg1 = (Dali::CustomActorImpl *)jarg1;
39797   {
39798     try {
39799       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39800     } catch (std::out_of_range& e) {
39801       {
39802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39803       };
39804     } catch (std::exception& e) {
39805       {
39806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39807       };
39808     } catch (Dali::DaliException e) {
39809       {
39810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39811       };
39812     } catch (...) {
39813       {
39814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39815       };
39816     }
39817   }
39818
39819   jresult = result;
39820   return jresult;
39821 }
39822
39823
39824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39825   void * jresult ;
39826   Dali::CustomActor *result = 0 ;
39827
39828   {
39829     try {
39830       result = (Dali::CustomActor *)new Dali::CustomActor();
39831     } catch (std::out_of_range& e) {
39832       {
39833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (std::exception& e) {
39836       {
39837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (Dali::DaliException e) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39842       };
39843     } catch (...) {
39844       {
39845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39846       };
39847     }
39848   }
39849
39850   jresult = (void *)result;
39851   return jresult;
39852 }
39853
39854
39855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39856   void * jresult ;
39857   Dali::BaseHandle arg1 ;
39858   Dali::BaseHandle *argp1 ;
39859   Dali::CustomActor result;
39860
39861   argp1 = (Dali::BaseHandle *)jarg1;
39862   if (!argp1) {
39863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39864     return 0;
39865   }
39866   arg1 = *argp1;
39867   {
39868     try {
39869       result = Dali::CustomActor::DownCast(arg1);
39870     } catch (std::out_of_range& e) {
39871       {
39872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39873       };
39874     } catch (std::exception& e) {
39875       {
39876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39877       };
39878     } catch (Dali::DaliException e) {
39879       {
39880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39881       };
39882     } catch (...) {
39883       {
39884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39885       };
39886     }
39887   }
39888
39889   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39890   return jresult;
39891 }
39892
39893
39894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39895   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39896
39897   arg1 = (Dali::CustomActor *)jarg1;
39898   {
39899     try {
39900       delete arg1;
39901     } catch (std::out_of_range& e) {
39902       {
39903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (std::exception& e) {
39906       {
39907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39908       };
39909     } catch (Dali::DaliException e) {
39910       {
39911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39912       };
39913     } catch (...) {
39914       {
39915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39916       };
39917     }
39918   }
39919
39920 }
39921
39922
39923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39924   void * jresult ;
39925   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39926   Dali::CustomActorImpl *result = 0 ;
39927
39928   arg1 = (Dali::CustomActor *)jarg1;
39929   {
39930     try {
39931       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39932     } catch (std::out_of_range& e) {
39933       {
39934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39935       };
39936     } catch (std::exception& e) {
39937       {
39938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39939       };
39940     } catch (Dali::DaliException e) {
39941       {
39942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39943       };
39944     } catch (...) {
39945       {
39946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39947       };
39948     }
39949   }
39950
39951   jresult = (void *)result;
39952   return jresult;
39953 }
39954
39955
39956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39957   void * jresult ;
39958   Dali::CustomActorImpl *arg1 = 0 ;
39959   Dali::CustomActor *result = 0 ;
39960
39961   arg1 = (Dali::CustomActorImpl *)jarg1;
39962   if (!arg1) {
39963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39964     return 0;
39965   }
39966   {
39967     try {
39968       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39969     } catch (std::out_of_range& e) {
39970       {
39971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39972       };
39973     } catch (std::exception& e) {
39974       {
39975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39976       };
39977     } catch (Dali::DaliException e) {
39978       {
39979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39980       };
39981     } catch (...) {
39982       {
39983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39984       };
39985     }
39986   }
39987
39988   jresult = (void *)result;
39989   return jresult;
39990 }
39991
39992
39993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39994   void * jresult ;
39995   Dali::CustomActor *arg1 = 0 ;
39996   Dali::CustomActor *result = 0 ;
39997
39998   arg1 = (Dali::CustomActor *)jarg1;
39999   if (!arg1) {
40000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40001     return 0;
40002   }
40003   {
40004     try {
40005       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40006     } catch (std::out_of_range& e) {
40007       {
40008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40009       };
40010     } catch (std::exception& e) {
40011       {
40012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40013       };
40014     } catch (Dali::DaliException e) {
40015       {
40016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40017       };
40018     } catch (...) {
40019       {
40020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40021       };
40022     }
40023   }
40024
40025   jresult = (void *)result;
40026   return jresult;
40027 }
40028
40029
40030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40031   void * jresult ;
40032   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40033   Dali::CustomActor *arg2 = 0 ;
40034   Dali::CustomActor *result = 0 ;
40035
40036   arg1 = (Dali::CustomActor *)jarg1;
40037   arg2 = (Dali::CustomActor *)jarg2;
40038   if (!arg2) {
40039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40040     return 0;
40041   }
40042   {
40043     try {
40044       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40045     } catch (std::out_of_range& e) {
40046       {
40047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40048       };
40049     } catch (std::exception& e) {
40050       {
40051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40052       };
40053     } catch (Dali::DaliException e) {
40054       {
40055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40056       };
40057     } catch (...) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40060       };
40061     }
40062   }
40063
40064   jresult = (void *)result;
40065   return jresult;
40066 }
40067
40068
40069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40070   int jresult ;
40071   int result;
40072
40073   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40074   jresult = (int)result;
40075   return jresult;
40076 }
40077
40078
40079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40080   int jresult ;
40081   int result;
40082
40083   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40084   jresult = (int)result;
40085   return jresult;
40086 }
40087
40088
40089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40090   int jresult ;
40091   int result;
40092
40093   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40094   jresult = (int)result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40100   int jresult ;
40101   int result;
40102
40103   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40104   jresult = (int)result;
40105   return jresult;
40106 }
40107
40108
40109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40110   int jresult ;
40111   int result;
40112
40113   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40114   jresult = (int)result;
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40120   int jresult ;
40121   int result;
40122
40123   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40124   jresult = (int)result;
40125   return jresult;
40126 }
40127
40128
40129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40130   int jresult ;
40131   int result;
40132
40133   result = (int)Dali::PanGestureDetector::Property::PANNING;
40134   jresult = (int)result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40140   void * jresult ;
40141   Dali::PanGestureDetector::Property *result = 0 ;
40142
40143   {
40144     try {
40145       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40146     } catch (std::out_of_range& e) {
40147       {
40148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40149       };
40150     } catch (std::exception& e) {
40151       {
40152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40153       };
40154     } catch (Dali::DaliException e) {
40155       {
40156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40157       };
40158     } catch (...) {
40159       {
40160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40161       };
40162     }
40163   }
40164
40165   jresult = (void *)result;
40166   return jresult;
40167 }
40168
40169
40170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40171   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40172
40173   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40174   {
40175     try {
40176       delete arg1;
40177     } catch (std::out_of_range& e) {
40178       {
40179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40180       };
40181     } catch (std::exception& e) {
40182       {
40183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40184       };
40185     } catch (Dali::DaliException e) {
40186       {
40187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40188       };
40189     } catch (...) {
40190       {
40191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40192       };
40193     }
40194   }
40195
40196 }
40197
40198
40199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40200   void * jresult ;
40201   Dali::Radian *result = 0 ;
40202
40203   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40204   jresult = (void *)result;
40205   return jresult;
40206 }
40207
40208
40209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40210   void * jresult ;
40211   Dali::Radian *result = 0 ;
40212
40213   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40214   jresult = (void *)result;
40215   return jresult;
40216 }
40217
40218
40219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40220   void * jresult ;
40221   Dali::Radian *result = 0 ;
40222
40223   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40224   jresult = (void *)result;
40225   return jresult;
40226 }
40227
40228
40229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40230   void * jresult ;
40231   Dali::Radian *result = 0 ;
40232
40233   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40234   jresult = (void *)result;
40235   return jresult;
40236 }
40237
40238
40239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40240   void * jresult ;
40241   Dali::Radian *result = 0 ;
40242
40243   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40244   jresult = (void *)result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40250   void * jresult ;
40251   Dali::Radian *result = 0 ;
40252
40253   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40254   jresult = (void *)result;
40255   return jresult;
40256 }
40257
40258
40259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40260   void * jresult ;
40261   Dali::Radian *result = 0 ;
40262
40263   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40264   jresult = (void *)result;
40265   return jresult;
40266 }
40267
40268
40269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40270   void * jresult ;
40271   Dali::PanGestureDetector *result = 0 ;
40272
40273   {
40274     try {
40275       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40276     } catch (std::out_of_range& e) {
40277       {
40278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40279       };
40280     } catch (std::exception& e) {
40281       {
40282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40283       };
40284     } catch (Dali::DaliException e) {
40285       {
40286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40287       };
40288     } catch (...) {
40289       {
40290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40291       };
40292     }
40293   }
40294
40295   jresult = (void *)result;
40296   return jresult;
40297 }
40298
40299
40300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40301   void * jresult ;
40302   Dali::PanGestureDetector result;
40303
40304   {
40305     try {
40306       result = Dali::PanGestureDetector::New();
40307     } catch (std::out_of_range& e) {
40308       {
40309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40310       };
40311     } catch (std::exception& e) {
40312       {
40313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40314       };
40315     } catch (Dali::DaliException e) {
40316       {
40317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40318       };
40319     } catch (...) {
40320       {
40321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40322       };
40323     }
40324   }
40325
40326   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40327   return jresult;
40328 }
40329
40330
40331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40332   void * jresult ;
40333   Dali::BaseHandle arg1 ;
40334   Dali::BaseHandle *argp1 ;
40335   Dali::PanGestureDetector result;
40336
40337   argp1 = (Dali::BaseHandle *)jarg1;
40338   if (!argp1) {
40339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40340     return 0;
40341   }
40342   arg1 = *argp1;
40343   {
40344     try {
40345       result = Dali::PanGestureDetector::DownCast(arg1);
40346     } catch (std::out_of_range& e) {
40347       {
40348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40349       };
40350     } catch (std::exception& e) {
40351       {
40352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40353       };
40354     } catch (Dali::DaliException e) {
40355       {
40356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40357       };
40358     } catch (...) {
40359       {
40360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40361       };
40362     }
40363   }
40364
40365   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40366   return jresult;
40367 }
40368
40369
40370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40371   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40372
40373   arg1 = (Dali::PanGestureDetector *)jarg1;
40374   {
40375     try {
40376       delete arg1;
40377     } catch (std::out_of_range& e) {
40378       {
40379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40380       };
40381     } catch (std::exception& e) {
40382       {
40383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40384       };
40385     } catch (Dali::DaliException e) {
40386       {
40387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40388       };
40389     } catch (...) {
40390       {
40391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40392       };
40393     }
40394   }
40395
40396 }
40397
40398
40399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40400   void * jresult ;
40401   Dali::PanGestureDetector *arg1 = 0 ;
40402   Dali::PanGestureDetector *result = 0 ;
40403
40404   arg1 = (Dali::PanGestureDetector *)jarg1;
40405   if (!arg1) {
40406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40407     return 0;
40408   }
40409   {
40410     try {
40411       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40412     } catch (std::out_of_range& e) {
40413       {
40414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40415       };
40416     } catch (std::exception& e) {
40417       {
40418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40419       };
40420     } catch (Dali::DaliException e) {
40421       {
40422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40423       };
40424     } catch (...) {
40425       {
40426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40427       };
40428     }
40429   }
40430
40431   jresult = (void *)result;
40432   return jresult;
40433 }
40434
40435
40436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40437   void * jresult ;
40438   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40439   Dali::PanGestureDetector *arg2 = 0 ;
40440   Dali::PanGestureDetector *result = 0 ;
40441
40442   arg1 = (Dali::PanGestureDetector *)jarg1;
40443   arg2 = (Dali::PanGestureDetector *)jarg2;
40444   if (!arg2) {
40445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40446     return 0;
40447   }
40448   {
40449     try {
40450       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40451     } catch (std::out_of_range& e) {
40452       {
40453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40454       };
40455     } catch (std::exception& e) {
40456       {
40457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40458       };
40459     } catch (Dali::DaliException e) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40462       };
40463     } catch (...) {
40464       {
40465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40466       };
40467     }
40468   }
40469
40470   jresult = (void *)result;
40471   return jresult;
40472 }
40473
40474
40475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40476   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40477   unsigned int arg2 ;
40478
40479   arg1 = (Dali::PanGestureDetector *)jarg1;
40480   arg2 = (unsigned int)jarg2;
40481   {
40482     try {
40483       (arg1)->SetMinimumTouchesRequired(arg2);
40484     } catch (std::out_of_range& e) {
40485       {
40486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40487       };
40488     } catch (std::exception& e) {
40489       {
40490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40491       };
40492     } catch (Dali::DaliException e) {
40493       {
40494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40495       };
40496     } catch (...) {
40497       {
40498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40499       };
40500     }
40501   }
40502
40503 }
40504
40505
40506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40507   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40508   unsigned int arg2 ;
40509
40510   arg1 = (Dali::PanGestureDetector *)jarg1;
40511   arg2 = (unsigned int)jarg2;
40512   {
40513     try {
40514       (arg1)->SetMaximumTouchesRequired(arg2);
40515     } catch (std::out_of_range& e) {
40516       {
40517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40518       };
40519     } catch (std::exception& e) {
40520       {
40521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (Dali::DaliException e) {
40524       {
40525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40526       };
40527     } catch (...) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40530       };
40531     }
40532   }
40533
40534 }
40535
40536
40537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40538   unsigned int jresult ;
40539   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40540   unsigned int result;
40541
40542   arg1 = (Dali::PanGestureDetector *)jarg1;
40543   {
40544     try {
40545       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40546     } catch (std::out_of_range& e) {
40547       {
40548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40549       };
40550     } catch (std::exception& e) {
40551       {
40552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40553       };
40554     } catch (Dali::DaliException e) {
40555       {
40556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40557       };
40558     } catch (...) {
40559       {
40560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40561       };
40562     }
40563   }
40564
40565   jresult = result;
40566   return jresult;
40567 }
40568
40569
40570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40571   unsigned int jresult ;
40572   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40573   unsigned int result;
40574
40575   arg1 = (Dali::PanGestureDetector *)jarg1;
40576   {
40577     try {
40578       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40579     } catch (std::out_of_range& e) {
40580       {
40581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40582       };
40583     } catch (std::exception& e) {
40584       {
40585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40586       };
40587     } catch (Dali::DaliException e) {
40588       {
40589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40590       };
40591     } catch (...) {
40592       {
40593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40594       };
40595     }
40596   }
40597
40598   jresult = result;
40599   return jresult;
40600 }
40601
40602
40603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40604   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40605   Dali::Radian arg2 ;
40606   Dali::Radian arg3 ;
40607   Dali::Radian *argp2 ;
40608   Dali::Radian *argp3 ;
40609
40610   arg1 = (Dali::PanGestureDetector *)jarg1;
40611   argp2 = (Dali::Radian *)jarg2;
40612   if (!argp2) {
40613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40614     return ;
40615   }
40616   arg2 = *argp2;
40617   argp3 = (Dali::Radian *)jarg3;
40618   if (!argp3) {
40619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40620     return ;
40621   }
40622   arg3 = *argp3;
40623   {
40624     try {
40625       (arg1)->AddAngle(arg2,arg3);
40626     } catch (std::out_of_range& e) {
40627       {
40628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40629       };
40630     } catch (std::exception& e) {
40631       {
40632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40633       };
40634     } catch (Dali::DaliException e) {
40635       {
40636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40637       };
40638     } catch (...) {
40639       {
40640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40641       };
40642     }
40643   }
40644
40645 }
40646
40647
40648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40649   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40650   Dali::Radian arg2 ;
40651   Dali::Radian *argp2 ;
40652
40653   arg1 = (Dali::PanGestureDetector *)jarg1;
40654   argp2 = (Dali::Radian *)jarg2;
40655   if (!argp2) {
40656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40657     return ;
40658   }
40659   arg2 = *argp2;
40660   {
40661     try {
40662       (arg1)->AddAngle(arg2);
40663     } catch (std::out_of_range& e) {
40664       {
40665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40666       };
40667     } catch (std::exception& e) {
40668       {
40669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40670       };
40671     } catch (Dali::DaliException e) {
40672       {
40673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40674       };
40675     } catch (...) {
40676       {
40677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40678       };
40679     }
40680   }
40681
40682 }
40683
40684
40685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40686   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40687   Dali::Radian arg2 ;
40688   Dali::Radian arg3 ;
40689   Dali::Radian *argp2 ;
40690   Dali::Radian *argp3 ;
40691
40692   arg1 = (Dali::PanGestureDetector *)jarg1;
40693   argp2 = (Dali::Radian *)jarg2;
40694   if (!argp2) {
40695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40696     return ;
40697   }
40698   arg2 = *argp2;
40699   argp3 = (Dali::Radian *)jarg3;
40700   if (!argp3) {
40701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40702     return ;
40703   }
40704   arg3 = *argp3;
40705   {
40706     try {
40707       (arg1)->AddDirection(arg2,arg3);
40708     } catch (std::out_of_range& e) {
40709       {
40710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40711       };
40712     } catch (std::exception& e) {
40713       {
40714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40715       };
40716     } catch (Dali::DaliException e) {
40717       {
40718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40719       };
40720     } catch (...) {
40721       {
40722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40723       };
40724     }
40725   }
40726
40727 }
40728
40729
40730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40731   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40732   Dali::Radian arg2 ;
40733   Dali::Radian *argp2 ;
40734
40735   arg1 = (Dali::PanGestureDetector *)jarg1;
40736   argp2 = (Dali::Radian *)jarg2;
40737   if (!argp2) {
40738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40739     return ;
40740   }
40741   arg2 = *argp2;
40742   {
40743     try {
40744       (arg1)->AddDirection(arg2);
40745     } catch (std::out_of_range& e) {
40746       {
40747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40748       };
40749     } catch (std::exception& e) {
40750       {
40751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40752       };
40753     } catch (Dali::DaliException e) {
40754       {
40755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40756       };
40757     } catch (...) {
40758       {
40759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40760       };
40761     }
40762   }
40763
40764 }
40765
40766
40767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40768   unsigned long jresult ;
40769   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40770   size_t result;
40771
40772   arg1 = (Dali::PanGestureDetector *)jarg1;
40773   {
40774     try {
40775       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40776     } catch (std::out_of_range& e) {
40777       {
40778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40779       };
40780     } catch (std::exception& e) {
40781       {
40782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40783       };
40784     } catch (Dali::DaliException e) {
40785       {
40786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40787       };
40788     } catch (...) {
40789       {
40790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40791       };
40792     }
40793   }
40794
40795   jresult = (unsigned long)result;
40796   return jresult;
40797 }
40798
40799
40800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40801   void * jresult ;
40802   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40803   size_t arg2 ;
40804   Dali::PanGestureDetector::AngleThresholdPair result;
40805
40806   arg1 = (Dali::PanGestureDetector *)jarg1;
40807   arg2 = (size_t)jarg2;
40808   {
40809     try {
40810       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40811     } catch (std::out_of_range& e) {
40812       {
40813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40814       };
40815     } catch (std::exception& e) {
40816       {
40817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40818       };
40819     } catch (Dali::DaliException e) {
40820       {
40821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40822       };
40823     } catch (...) {
40824       {
40825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40826       };
40827     }
40828   }
40829
40830   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40831   return jresult;
40832 }
40833
40834
40835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40836   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40837
40838   arg1 = (Dali::PanGestureDetector *)jarg1;
40839   {
40840     try {
40841       (arg1)->ClearAngles();
40842     } catch (std::out_of_range& e) {
40843       {
40844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40845       };
40846     } catch (std::exception& e) {
40847       {
40848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40849       };
40850     } catch (Dali::DaliException e) {
40851       {
40852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40853       };
40854     } catch (...) {
40855       {
40856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40857       };
40858     }
40859   }
40860
40861 }
40862
40863
40864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40865   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40866   Dali::Radian arg2 ;
40867   Dali::Radian *argp2 ;
40868
40869   arg1 = (Dali::PanGestureDetector *)jarg1;
40870   argp2 = (Dali::Radian *)jarg2;
40871   if (!argp2) {
40872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40873     return ;
40874   }
40875   arg2 = *argp2;
40876   {
40877     try {
40878       (arg1)->RemoveAngle(arg2);
40879     } catch (std::out_of_range& e) {
40880       {
40881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40882       };
40883     } catch (std::exception& e) {
40884       {
40885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40886       };
40887     } catch (Dali::DaliException e) {
40888       {
40889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40890       };
40891     } catch (...) {
40892       {
40893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40894       };
40895     }
40896   }
40897
40898 }
40899
40900
40901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40902   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40903   Dali::Radian arg2 ;
40904   Dali::Radian *argp2 ;
40905
40906   arg1 = (Dali::PanGestureDetector *)jarg1;
40907   argp2 = (Dali::Radian *)jarg2;
40908   if (!argp2) {
40909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40910     return ;
40911   }
40912   arg2 = *argp2;
40913   {
40914     try {
40915       (arg1)->RemoveDirection(arg2);
40916     } catch (std::out_of_range& e) {
40917       {
40918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40919       };
40920     } catch (std::exception& e) {
40921       {
40922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40923       };
40924     } catch (Dali::DaliException e) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40927       };
40928     } catch (...) {
40929       {
40930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40931       };
40932     }
40933   }
40934
40935 }
40936
40937
40938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40939   void * jresult ;
40940   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40941   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40942
40943   arg1 = (Dali::PanGestureDetector *)jarg1;
40944   {
40945     try {
40946       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40947     } catch (std::out_of_range& e) {
40948       {
40949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40950       };
40951     } catch (std::exception& e) {
40952       {
40953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (Dali::DaliException e) {
40956       {
40957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40958       };
40959     } catch (...) {
40960       {
40961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40962       };
40963     }
40964   }
40965
40966   jresult = (void *)result;
40967   return jresult;
40968 }
40969
40970
40971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40972   Dali::PanGesture *arg1 = 0 ;
40973
40974   arg1 = (Dali::PanGesture *)jarg1;
40975   if (!arg1) {
40976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40977     return ;
40978   }
40979   {
40980     try {
40981       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40982     } catch (std::out_of_range& e) {
40983       {
40984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40985       };
40986     } catch (std::exception& e) {
40987       {
40988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40989       };
40990     } catch (Dali::DaliException e) {
40991       {
40992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40993       };
40994     } catch (...) {
40995       {
40996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40997       };
40998     }
40999   }
41000
41001 }
41002
41003
41004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41005   void * jresult ;
41006   Dali::PanGesture *result = 0 ;
41007
41008   {
41009     try {
41010       result = (Dali::PanGesture *)new Dali::PanGesture();
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41026       };
41027     }
41028   }
41029
41030   jresult = (void *)result;
41031   return jresult;
41032 }
41033
41034
41035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41036   void * jresult ;
41037   Dali::Gesture::State arg1 ;
41038   Dali::PanGesture *result = 0 ;
41039
41040   arg1 = (Dali::Gesture::State)jarg1;
41041   {
41042     try {
41043       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41044     } catch (std::out_of_range& e) {
41045       {
41046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41047       };
41048     } catch (std::exception& e) {
41049       {
41050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41051       };
41052     } catch (Dali::DaliException e) {
41053       {
41054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41055       };
41056     } catch (...) {
41057       {
41058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41059       };
41060     }
41061   }
41062
41063   jresult = (void *)result;
41064   return jresult;
41065 }
41066
41067
41068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41069   void * jresult ;
41070   Dali::PanGesture *arg1 = 0 ;
41071   Dali::PanGesture *result = 0 ;
41072
41073   arg1 = (Dali::PanGesture *)jarg1;
41074   if (!arg1) {
41075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41076     return 0;
41077   }
41078   {
41079     try {
41080       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
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 = (void *)result;
41101   return jresult;
41102 }
41103
41104
41105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41106   void * jresult ;
41107   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41108   Dali::PanGesture *arg2 = 0 ;
41109   Dali::PanGesture *result = 0 ;
41110
41111   arg1 = (Dali::PanGesture *)jarg1;
41112   arg2 = (Dali::PanGesture *)jarg2;
41113   if (!arg2) {
41114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41115     return 0;
41116   }
41117   {
41118     try {
41119       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41120     } catch (std::out_of_range& e) {
41121       {
41122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41123       };
41124     } catch (std::exception& e) {
41125       {
41126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (Dali::DaliException e) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41131       };
41132     } catch (...) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41135       };
41136     }
41137   }
41138
41139   jresult = (void *)result;
41140   return jresult;
41141 }
41142
41143
41144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41145   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41146
41147   arg1 = (Dali::PanGesture *)jarg1;
41148   {
41149     try {
41150       delete arg1;
41151     } catch (std::out_of_range& e) {
41152       {
41153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41154       };
41155     } catch (std::exception& e) {
41156       {
41157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41158       };
41159     } catch (Dali::DaliException e) {
41160       {
41161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41162       };
41163     } catch (...) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41166       };
41167     }
41168   }
41169
41170 }
41171
41172
41173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41174   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41175   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41176
41177   arg1 = (Dali::PanGesture *)jarg1;
41178   arg2 = (Dali::Vector2 *)jarg2;
41179   if (arg1) (arg1)->velocity = *arg2;
41180 }
41181
41182
41183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41184   void * jresult ;
41185   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41186   Dali::Vector2 *result = 0 ;
41187
41188   arg1 = (Dali::PanGesture *)jarg1;
41189   result = (Dali::Vector2 *)& ((arg1)->velocity);
41190   jresult = (void *)result;
41191   return jresult;
41192 }
41193
41194
41195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41196   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41197   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41198
41199   arg1 = (Dali::PanGesture *)jarg1;
41200   arg2 = (Dali::Vector2 *)jarg2;
41201   if (arg1) (arg1)->displacement = *arg2;
41202 }
41203
41204
41205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41206   void * jresult ;
41207   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41208   Dali::Vector2 *result = 0 ;
41209
41210   arg1 = (Dali::PanGesture *)jarg1;
41211   result = (Dali::Vector2 *)& ((arg1)->displacement);
41212   jresult = (void *)result;
41213   return jresult;
41214 }
41215
41216
41217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41218   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41219   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41220
41221   arg1 = (Dali::PanGesture *)jarg1;
41222   arg2 = (Dali::Vector2 *)jarg2;
41223   if (arg1) (arg1)->position = *arg2;
41224 }
41225
41226
41227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41228   void * jresult ;
41229   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41230   Dali::Vector2 *result = 0 ;
41231
41232   arg1 = (Dali::PanGesture *)jarg1;
41233   result = (Dali::Vector2 *)& ((arg1)->position);
41234   jresult = (void *)result;
41235   return jresult;
41236 }
41237
41238
41239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41240   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41241   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41242
41243   arg1 = (Dali::PanGesture *)jarg1;
41244   arg2 = (Dali::Vector2 *)jarg2;
41245   if (arg1) (arg1)->screenVelocity = *arg2;
41246 }
41247
41248
41249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41250   void * jresult ;
41251   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41252   Dali::Vector2 *result = 0 ;
41253
41254   arg1 = (Dali::PanGesture *)jarg1;
41255   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41256   jresult = (void *)result;
41257   return jresult;
41258 }
41259
41260
41261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41262   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41263   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41264
41265   arg1 = (Dali::PanGesture *)jarg1;
41266   arg2 = (Dali::Vector2 *)jarg2;
41267   if (arg1) (arg1)->screenDisplacement = *arg2;
41268 }
41269
41270
41271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41272   void * jresult ;
41273   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41274   Dali::Vector2 *result = 0 ;
41275
41276   arg1 = (Dali::PanGesture *)jarg1;
41277   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41278   jresult = (void *)result;
41279   return jresult;
41280 }
41281
41282
41283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41284   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41285   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41286
41287   arg1 = (Dali::PanGesture *)jarg1;
41288   arg2 = (Dali::Vector2 *)jarg2;
41289   if (arg1) (arg1)->screenPosition = *arg2;
41290 }
41291
41292
41293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41294   void * jresult ;
41295   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41296   Dali::Vector2 *result = 0 ;
41297
41298   arg1 = (Dali::PanGesture *)jarg1;
41299   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41300   jresult = (void *)result;
41301   return jresult;
41302 }
41303
41304
41305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41306   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41307   unsigned int arg2 ;
41308
41309   arg1 = (Dali::PanGesture *)jarg1;
41310   arg2 = (unsigned int)jarg2;
41311   if (arg1) (arg1)->numberOfTouches = arg2;
41312 }
41313
41314
41315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41316   unsigned int jresult ;
41317   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41318   unsigned int result;
41319
41320   arg1 = (Dali::PanGesture *)jarg1;
41321   result = (unsigned int) ((arg1)->numberOfTouches);
41322   jresult = result;
41323   return jresult;
41324 }
41325
41326
41327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41328   float jresult ;
41329   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41330   float result;
41331
41332   arg1 = (Dali::PanGesture *)jarg1;
41333   {
41334     try {
41335       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (Dali::DaliException e) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41347       };
41348     } catch (...) {
41349       {
41350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41351       };
41352     }
41353   }
41354
41355   jresult = result;
41356   return jresult;
41357 }
41358
41359
41360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41361   float jresult ;
41362   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41363   float result;
41364
41365   arg1 = (Dali::PanGesture *)jarg1;
41366   {
41367     try {
41368       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41369     } catch (std::out_of_range& e) {
41370       {
41371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41372       };
41373     } catch (std::exception& e) {
41374       {
41375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41376       };
41377     } catch (Dali::DaliException e) {
41378       {
41379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41380       };
41381     } catch (...) {
41382       {
41383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41384       };
41385     }
41386   }
41387
41388   jresult = result;
41389   return jresult;
41390 }
41391
41392
41393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41394   float jresult ;
41395   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41396   float result;
41397
41398   arg1 = (Dali::PanGesture *)jarg1;
41399   {
41400     try {
41401       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41402     } catch (std::out_of_range& e) {
41403       {
41404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41405       };
41406     } catch (std::exception& e) {
41407       {
41408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (Dali::DaliException e) {
41411       {
41412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41413       };
41414     } catch (...) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41417       };
41418     }
41419   }
41420
41421   jresult = result;
41422   return jresult;
41423 }
41424
41425
41426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41427   float jresult ;
41428   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41429   float result;
41430
41431   arg1 = (Dali::PanGesture *)jarg1;
41432   {
41433     try {
41434       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41435     } catch (std::out_of_range& e) {
41436       {
41437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41438       };
41439     } catch (std::exception& e) {
41440       {
41441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41442       };
41443     } catch (Dali::DaliException e) {
41444       {
41445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41446       };
41447     } catch (...) {
41448       {
41449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41450       };
41451     }
41452   }
41453
41454   jresult = result;
41455   return jresult;
41456 }
41457
41458
41459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41460   void * jresult ;
41461   Dali::PinchGestureDetector *result = 0 ;
41462
41463   {
41464     try {
41465       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41466     } catch (std::out_of_range& e) {
41467       {
41468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41469       };
41470     } catch (std::exception& e) {
41471       {
41472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41473       };
41474     } catch (Dali::DaliException e) {
41475       {
41476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41477       };
41478     } catch (...) {
41479       {
41480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41481       };
41482     }
41483   }
41484
41485   jresult = (void *)result;
41486   return jresult;
41487 }
41488
41489
41490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41491   void * jresult ;
41492   Dali::PinchGestureDetector result;
41493
41494   {
41495     try {
41496       result = Dali::PinchGestureDetector::New();
41497     } catch (std::out_of_range& e) {
41498       {
41499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41500       };
41501     } catch (std::exception& e) {
41502       {
41503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41504       };
41505     } catch (Dali::DaliException e) {
41506       {
41507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41508       };
41509     } catch (...) {
41510       {
41511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41512       };
41513     }
41514   }
41515
41516   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41517   return jresult;
41518 }
41519
41520
41521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41522   void * jresult ;
41523   Dali::BaseHandle arg1 ;
41524   Dali::BaseHandle *argp1 ;
41525   Dali::PinchGestureDetector result;
41526
41527   argp1 = (Dali::BaseHandle *)jarg1;
41528   if (!argp1) {
41529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41530     return 0;
41531   }
41532   arg1 = *argp1;
41533   {
41534     try {
41535       result = Dali::PinchGestureDetector::DownCast(arg1);
41536     } catch (std::out_of_range& e) {
41537       {
41538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (std::exception& e) {
41541       {
41542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41543       };
41544     } catch (Dali::DaliException e) {
41545       {
41546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41547       };
41548     } catch (...) {
41549       {
41550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41551       };
41552     }
41553   }
41554
41555   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41556   return jresult;
41557 }
41558
41559
41560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41561   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41562
41563   arg1 = (Dali::PinchGestureDetector *)jarg1;
41564   {
41565     try {
41566       delete arg1;
41567     } catch (std::out_of_range& e) {
41568       {
41569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41570       };
41571     } catch (std::exception& e) {
41572       {
41573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41574       };
41575     } catch (Dali::DaliException e) {
41576       {
41577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41578       };
41579     } catch (...) {
41580       {
41581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41582       };
41583     }
41584   }
41585
41586 }
41587
41588
41589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41590   void * jresult ;
41591   Dali::PinchGestureDetector *arg1 = 0 ;
41592   Dali::PinchGestureDetector *result = 0 ;
41593
41594   arg1 = (Dali::PinchGestureDetector *)jarg1;
41595   if (!arg1) {
41596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41597     return 0;
41598   }
41599   {
41600     try {
41601       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41602     } catch (std::out_of_range& e) {
41603       {
41604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41605       };
41606     } catch (std::exception& e) {
41607       {
41608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41609       };
41610     } catch (Dali::DaliException e) {
41611       {
41612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41613       };
41614     } catch (...) {
41615       {
41616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41617       };
41618     }
41619   }
41620
41621   jresult = (void *)result;
41622   return jresult;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41627   void * jresult ;
41628   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41629   Dali::PinchGestureDetector *arg2 = 0 ;
41630   Dali::PinchGestureDetector *result = 0 ;
41631
41632   arg1 = (Dali::PinchGestureDetector *)jarg1;
41633   arg2 = (Dali::PinchGestureDetector *)jarg2;
41634   if (!arg2) {
41635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41636     return 0;
41637   }
41638   {
41639     try {
41640       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
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 = (void *)result;
41661   return jresult;
41662 }
41663
41664
41665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41666   void * jresult ;
41667   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41668   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41669
41670   arg1 = (Dali::PinchGestureDetector *)jarg1;
41671   {
41672     try {
41673       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41674     } catch (std::out_of_range& e) {
41675       {
41676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41677       };
41678     } catch (std::exception& e) {
41679       {
41680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41681       };
41682     } catch (Dali::DaliException e) {
41683       {
41684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41685       };
41686     } catch (...) {
41687       {
41688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41689       };
41690     }
41691   }
41692
41693   jresult = (void *)result;
41694   return jresult;
41695 }
41696
41697
41698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41699   void * jresult ;
41700   Dali::Gesture::State arg1 ;
41701   Dali::PinchGesture *result = 0 ;
41702
41703   arg1 = (Dali::Gesture::State)jarg1;
41704   {
41705     try {
41706       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41707     } catch (std::out_of_range& e) {
41708       {
41709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41710       };
41711     } catch (std::exception& e) {
41712       {
41713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41714       };
41715     } catch (Dali::DaliException e) {
41716       {
41717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41718       };
41719     } catch (...) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41722       };
41723     }
41724   }
41725
41726   jresult = (void *)result;
41727   return jresult;
41728 }
41729
41730
41731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41732   void * jresult ;
41733   Dali::PinchGesture *arg1 = 0 ;
41734   Dali::PinchGesture *result = 0 ;
41735
41736   arg1 = (Dali::PinchGesture *)jarg1;
41737   if (!arg1) {
41738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41739     return 0;
41740   }
41741   {
41742     try {
41743       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41744     } catch (std::out_of_range& e) {
41745       {
41746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41747       };
41748     } catch (std::exception& e) {
41749       {
41750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (Dali::DaliException e) {
41753       {
41754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41755       };
41756     } catch (...) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41759       };
41760     }
41761   }
41762
41763   jresult = (void *)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41769   void * jresult ;
41770   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41771   Dali::PinchGesture *arg2 = 0 ;
41772   Dali::PinchGesture *result = 0 ;
41773
41774   arg1 = (Dali::PinchGesture *)jarg1;
41775   arg2 = (Dali::PinchGesture *)jarg2;
41776   if (!arg2) {
41777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41778     return 0;
41779   }
41780   {
41781     try {
41782       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (Dali::DaliException e) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41794       };
41795     } catch (...) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41798       };
41799     }
41800   }
41801
41802   jresult = (void *)result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41808   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41809
41810   arg1 = (Dali::PinchGesture *)jarg1;
41811   {
41812     try {
41813       delete arg1;
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41829       };
41830     }
41831   }
41832
41833 }
41834
41835
41836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41837   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41838   float arg2 ;
41839
41840   arg1 = (Dali::PinchGesture *)jarg1;
41841   arg2 = (float)jarg2;
41842   if (arg1) (arg1)->scale = arg2;
41843 }
41844
41845
41846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41847   float jresult ;
41848   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41849   float result;
41850
41851   arg1 = (Dali::PinchGesture *)jarg1;
41852   result = (float) ((arg1)->scale);
41853   jresult = result;
41854   return jresult;
41855 }
41856
41857
41858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41859   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41860   float arg2 ;
41861
41862   arg1 = (Dali::PinchGesture *)jarg1;
41863   arg2 = (float)jarg2;
41864   if (arg1) (arg1)->speed = arg2;
41865 }
41866
41867
41868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41869   float jresult ;
41870   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41871   float result;
41872
41873   arg1 = (Dali::PinchGesture *)jarg1;
41874   result = (float) ((arg1)->speed);
41875   jresult = result;
41876   return jresult;
41877 }
41878
41879
41880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41881   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41882   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41883
41884   arg1 = (Dali::PinchGesture *)jarg1;
41885   arg2 = (Dali::Vector2 *)jarg2;
41886   if (arg1) (arg1)->screenCenterPoint = *arg2;
41887 }
41888
41889
41890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41891   void * jresult ;
41892   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41893   Dali::Vector2 *result = 0 ;
41894
41895   arg1 = (Dali::PinchGesture *)jarg1;
41896   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41897   jresult = (void *)result;
41898   return jresult;
41899 }
41900
41901
41902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41903   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41904   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41905
41906   arg1 = (Dali::PinchGesture *)jarg1;
41907   arg2 = (Dali::Vector2 *)jarg2;
41908   if (arg1) (arg1)->localCenterPoint = *arg2;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41913   void * jresult ;
41914   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41915   Dali::Vector2 *result = 0 ;
41916
41917   arg1 = (Dali::PinchGesture *)jarg1;
41918   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41919   jresult = (void *)result;
41920   return jresult;
41921 }
41922
41923
41924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41925   void * jresult ;
41926   Dali::TapGestureDetector *result = 0 ;
41927
41928   {
41929     try {
41930       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41931     } catch (std::out_of_range& e) {
41932       {
41933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41934       };
41935     } catch (std::exception& e) {
41936       {
41937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41938       };
41939     } catch (Dali::DaliException e) {
41940       {
41941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41942       };
41943     } catch (...) {
41944       {
41945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41946       };
41947     }
41948   }
41949
41950   jresult = (void *)result;
41951   return jresult;
41952 }
41953
41954
41955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41956   void * jresult ;
41957   Dali::TapGestureDetector result;
41958
41959   {
41960     try {
41961       result = Dali::TapGestureDetector::New();
41962     } catch (std::out_of_range& e) {
41963       {
41964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41965       };
41966     } catch (std::exception& e) {
41967       {
41968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41969       };
41970     } catch (Dali::DaliException e) {
41971       {
41972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41973       };
41974     } catch (...) {
41975       {
41976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41977       };
41978     }
41979   }
41980
41981   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41982   return jresult;
41983 }
41984
41985
41986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41987   void * jresult ;
41988   unsigned int arg1 ;
41989   Dali::TapGestureDetector result;
41990
41991   arg1 = (unsigned int)jarg1;
41992   {
41993     try {
41994       result = Dali::TapGestureDetector::New(arg1);
41995     } catch (std::out_of_range& e) {
41996       {
41997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41998       };
41999     } catch (std::exception& e) {
42000       {
42001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42002       };
42003     } catch (Dali::DaliException e) {
42004       {
42005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42006       };
42007     } catch (...) {
42008       {
42009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42010       };
42011     }
42012   }
42013
42014   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42015   return jresult;
42016 }
42017
42018
42019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42020   void * jresult ;
42021   Dali::BaseHandle arg1 ;
42022   Dali::BaseHandle *argp1 ;
42023   Dali::TapGestureDetector result;
42024
42025   argp1 = (Dali::BaseHandle *)jarg1;
42026   if (!argp1) {
42027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42028     return 0;
42029   }
42030   arg1 = *argp1;
42031   {
42032     try {
42033       result = Dali::TapGestureDetector::DownCast(arg1);
42034     } catch (std::out_of_range& e) {
42035       {
42036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42037       };
42038     } catch (std::exception& e) {
42039       {
42040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42041       };
42042     } catch (Dali::DaliException e) {
42043       {
42044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42045       };
42046     } catch (...) {
42047       {
42048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42049       };
42050     }
42051   }
42052
42053   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42054   return jresult;
42055 }
42056
42057
42058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42059   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42060
42061   arg1 = (Dali::TapGestureDetector *)jarg1;
42062   {
42063     try {
42064       delete arg1;
42065     } catch (std::out_of_range& e) {
42066       {
42067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42068       };
42069     } catch (std::exception& e) {
42070       {
42071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42072       };
42073     } catch (Dali::DaliException e) {
42074       {
42075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42080       };
42081     }
42082   }
42083
42084 }
42085
42086
42087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42088   void * jresult ;
42089   Dali::TapGestureDetector *arg1 = 0 ;
42090   Dali::TapGestureDetector *result = 0 ;
42091
42092   arg1 = (Dali::TapGestureDetector *)jarg1;
42093   if (!arg1) {
42094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42095     return 0;
42096   }
42097   {
42098     try {
42099       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42100     } catch (std::out_of_range& e) {
42101       {
42102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (std::exception& e) {
42105       {
42106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (Dali::DaliException e) {
42109       {
42110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42111       };
42112     } catch (...) {
42113       {
42114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42115       };
42116     }
42117   }
42118
42119   jresult = (void *)result;
42120   return jresult;
42121 }
42122
42123
42124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42125   void * jresult ;
42126   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42127   Dali::TapGestureDetector *arg2 = 0 ;
42128   Dali::TapGestureDetector *result = 0 ;
42129
42130   arg1 = (Dali::TapGestureDetector *)jarg1;
42131   arg2 = (Dali::TapGestureDetector *)jarg2;
42132   if (!arg2) {
42133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42134     return 0;
42135   }
42136   {
42137     try {
42138       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42139     } catch (std::out_of_range& e) {
42140       {
42141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42142       };
42143     } catch (std::exception& e) {
42144       {
42145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42146       };
42147     } catch (Dali::DaliException e) {
42148       {
42149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42150       };
42151     } catch (...) {
42152       {
42153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42154       };
42155     }
42156   }
42157
42158   jresult = (void *)result;
42159   return jresult;
42160 }
42161
42162
42163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42164   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42165   unsigned int arg2 ;
42166
42167   arg1 = (Dali::TapGestureDetector *)jarg1;
42168   arg2 = (unsigned int)jarg2;
42169   {
42170     try {
42171       (arg1)->SetMinimumTapsRequired(arg2);
42172     } catch (std::out_of_range& e) {
42173       {
42174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42175       };
42176     } catch (std::exception& e) {
42177       {
42178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42179       };
42180     } catch (Dali::DaliException e) {
42181       {
42182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42183       };
42184     } catch (...) {
42185       {
42186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42187       };
42188     }
42189   }
42190
42191 }
42192
42193
42194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42195   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42196   unsigned int arg2 ;
42197
42198   arg1 = (Dali::TapGestureDetector *)jarg1;
42199   arg2 = (unsigned int)jarg2;
42200   {
42201     try {
42202       (arg1)->SetMaximumTapsRequired(arg2);
42203     } catch (std::out_of_range& e) {
42204       {
42205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42206       };
42207     } catch (std::exception& e) {
42208       {
42209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42210       };
42211     } catch (Dali::DaliException e) {
42212       {
42213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42214       };
42215     } catch (...) {
42216       {
42217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42218       };
42219     }
42220   }
42221
42222 }
42223
42224
42225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42226   unsigned int jresult ;
42227   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42228   unsigned int result;
42229
42230   arg1 = (Dali::TapGestureDetector *)jarg1;
42231   {
42232     try {
42233       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
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 = result;
42254   return jresult;
42255 }
42256
42257
42258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42259   unsigned int jresult ;
42260   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42261   unsigned int result;
42262
42263   arg1 = (Dali::TapGestureDetector *)jarg1;
42264   {
42265     try {
42266       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
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 = result;
42287   return jresult;
42288 }
42289
42290
42291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42292   void * jresult ;
42293   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42294   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42295
42296   arg1 = (Dali::TapGestureDetector *)jarg1;
42297   {
42298     try {
42299       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42300     } catch (std::out_of_range& e) {
42301       {
42302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42303       };
42304     } catch (std::exception& e) {
42305       {
42306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42307       };
42308     } catch (Dali::DaliException e) {
42309       {
42310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42311       };
42312     } catch (...) {
42313       {
42314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42315       };
42316     }
42317   }
42318
42319   jresult = (void *)result;
42320   return jresult;
42321 }
42322
42323
42324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42325   void * jresult ;
42326   Dali::TapGesture *result = 0 ;
42327
42328   {
42329     try {
42330       result = (Dali::TapGesture *)new Dali::TapGesture();
42331     } catch (std::out_of_range& e) {
42332       {
42333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42334       };
42335     } catch (std::exception& e) {
42336       {
42337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42338       };
42339     } catch (Dali::DaliException e) {
42340       {
42341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42342       };
42343     } catch (...) {
42344       {
42345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42346       };
42347     }
42348   }
42349
42350   jresult = (void *)result;
42351   return jresult;
42352 }
42353
42354
42355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42356   void * jresult ;
42357   Dali::TapGesture *arg1 = 0 ;
42358   Dali::TapGesture *result = 0 ;
42359
42360   arg1 = (Dali::TapGesture *)jarg1;
42361   if (!arg1) {
42362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42363     return 0;
42364   }
42365   {
42366     try {
42367       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42368     } catch (std::out_of_range& e) {
42369       {
42370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42371       };
42372     } catch (std::exception& e) {
42373       {
42374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42375       };
42376     } catch (Dali::DaliException e) {
42377       {
42378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42379       };
42380     } catch (...) {
42381       {
42382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42383       };
42384     }
42385   }
42386
42387   jresult = (void *)result;
42388   return jresult;
42389 }
42390
42391
42392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42393   void * jresult ;
42394   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42395   Dali::TapGesture *arg2 = 0 ;
42396   Dali::TapGesture *result = 0 ;
42397
42398   arg1 = (Dali::TapGesture *)jarg1;
42399   arg2 = (Dali::TapGesture *)jarg2;
42400   if (!arg2) {
42401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42402     return 0;
42403   }
42404   {
42405     try {
42406       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42407     } catch (std::out_of_range& e) {
42408       {
42409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42410       };
42411     } catch (std::exception& e) {
42412       {
42413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42414       };
42415     } catch (Dali::DaliException e) {
42416       {
42417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42418       };
42419     } catch (...) {
42420       {
42421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42422       };
42423     }
42424   }
42425
42426   jresult = (void *)result;
42427   return jresult;
42428 }
42429
42430
42431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42432   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42433
42434   arg1 = (Dali::TapGesture *)jarg1;
42435   {
42436     try {
42437       delete arg1;
42438     } catch (std::out_of_range& e) {
42439       {
42440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42441       };
42442     } catch (std::exception& e) {
42443       {
42444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42445       };
42446     } catch (Dali::DaliException e) {
42447       {
42448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42449       };
42450     } catch (...) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42453       };
42454     }
42455   }
42456
42457 }
42458
42459
42460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42461   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42462   unsigned int arg2 ;
42463
42464   arg1 = (Dali::TapGesture *)jarg1;
42465   arg2 = (unsigned int)jarg2;
42466   if (arg1) (arg1)->numberOfTaps = arg2;
42467 }
42468
42469
42470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42471   unsigned int jresult ;
42472   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42473   unsigned int result;
42474
42475   arg1 = (Dali::TapGesture *)jarg1;
42476   result = (unsigned int) ((arg1)->numberOfTaps);
42477   jresult = result;
42478   return jresult;
42479 }
42480
42481
42482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42483   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42484   unsigned int arg2 ;
42485
42486   arg1 = (Dali::TapGesture *)jarg1;
42487   arg2 = (unsigned int)jarg2;
42488   if (arg1) (arg1)->numberOfTouches = arg2;
42489 }
42490
42491
42492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42493   unsigned int jresult ;
42494   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42495   unsigned int result;
42496
42497   arg1 = (Dali::TapGesture *)jarg1;
42498   result = (unsigned int) ((arg1)->numberOfTouches);
42499   jresult = result;
42500   return jresult;
42501 }
42502
42503
42504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42505   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42506   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42507
42508   arg1 = (Dali::TapGesture *)jarg1;
42509   arg2 = (Dali::Vector2 *)jarg2;
42510   if (arg1) (arg1)->screenPoint = *arg2;
42511 }
42512
42513
42514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42515   void * jresult ;
42516   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42517   Dali::Vector2 *result = 0 ;
42518
42519   arg1 = (Dali::TapGesture *)jarg1;
42520   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42521   jresult = (void *)result;
42522   return jresult;
42523 }
42524
42525
42526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42527   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42528   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42529
42530   arg1 = (Dali::TapGesture *)jarg1;
42531   arg2 = (Dali::Vector2 *)jarg2;
42532   if (arg1) (arg1)->localPoint = *arg2;
42533 }
42534
42535
42536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42537   void * jresult ;
42538   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42539   Dali::Vector2 *result = 0 ;
42540
42541   arg1 = (Dali::TapGesture *)jarg1;
42542   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42543   jresult = (void *)result;
42544   return jresult;
42545 }
42546
42547
42548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42549   void * jresult ;
42550   Dali::AlphaFunction *result = 0 ;
42551
42552   {
42553     try {
42554       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42555     } catch (std::out_of_range& e) {
42556       {
42557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42558       };
42559     } catch (std::exception& e) {
42560       {
42561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42562       };
42563     } catch (Dali::DaliException e) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42566       };
42567     } catch (...) {
42568       {
42569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42570       };
42571     }
42572   }
42573
42574   jresult = (void *)result;
42575   return jresult;
42576 }
42577
42578
42579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42580   void * jresult ;
42581   Dali::AlphaFunction::BuiltinFunction arg1 ;
42582   Dali::AlphaFunction *result = 0 ;
42583
42584   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42585   {
42586     try {
42587       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42588     } catch (std::out_of_range& e) {
42589       {
42590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42591       };
42592     } catch (std::exception& e) {
42593       {
42594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (Dali::DaliException e) {
42597       {
42598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42599       };
42600     } catch (...) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42603       };
42604     }
42605   }
42606
42607   jresult = (void *)result;
42608   return jresult;
42609 }
42610
42611
42612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42613   void * jresult ;
42614   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42615   Dali::AlphaFunction *result = 0 ;
42616
42617   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42618   {
42619     try {
42620       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42621     } catch (std::out_of_range& e) {
42622       {
42623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42624       };
42625     } catch (std::exception& e) {
42626       {
42627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42628       };
42629     } catch (Dali::DaliException e) {
42630       {
42631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42632       };
42633     } catch (...) {
42634       {
42635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42636       };
42637     }
42638   }
42639
42640   jresult = (void *)result;
42641   return jresult;
42642 }
42643
42644
42645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42646   void * jresult ;
42647   Dali::Vector2 *arg1 = 0 ;
42648   Dali::Vector2 *arg2 = 0 ;
42649   Dali::AlphaFunction *result = 0 ;
42650
42651   arg1 = (Dali::Vector2 *)jarg1;
42652   if (!arg1) {
42653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42654     return 0;
42655   }
42656   arg2 = (Dali::Vector2 *)jarg2;
42657   if (!arg2) {
42658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42659     return 0;
42660   }
42661   {
42662     try {
42663       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42664     } catch (std::out_of_range& e) {
42665       {
42666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42667       };
42668     } catch (std::exception& e) {
42669       {
42670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42671       };
42672     } catch (Dali::DaliException e) {
42673       {
42674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42675       };
42676     } catch (...) {
42677       {
42678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42679       };
42680     }
42681   }
42682
42683   jresult = (void *)result;
42684   return jresult;
42685 }
42686
42687
42688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42689   void * jresult ;
42690   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42691   Dali::Vector4 result;
42692
42693   arg1 = (Dali::AlphaFunction *)jarg1;
42694   {
42695     try {
42696       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42704       };
42705     } catch (Dali::DaliException e) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42708       };
42709     } catch (...) {
42710       {
42711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42712       };
42713     }
42714   }
42715
42716   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42717   return jresult;
42718 }
42719
42720
42721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42722   void * jresult ;
42723   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42724   Dali::AlphaFunctionPrototype result;
42725
42726   arg1 = (Dali::AlphaFunction *)jarg1;
42727   {
42728     try {
42729       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42730     } catch (std::out_of_range& e) {
42731       {
42732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42733       };
42734     } catch (std::exception& e) {
42735       {
42736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42737       };
42738     } catch (Dali::DaliException e) {
42739       {
42740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42741       };
42742     } catch (...) {
42743       {
42744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42745       };
42746     }
42747   }
42748
42749   jresult = (void *)result;
42750   return jresult;
42751 }
42752
42753
42754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42755   int jresult ;
42756   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42757   Dali::AlphaFunction::BuiltinFunction result;
42758
42759   arg1 = (Dali::AlphaFunction *)jarg1;
42760   {
42761     try {
42762       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42763     } catch (std::out_of_range& e) {
42764       {
42765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42766       };
42767     } catch (std::exception& e) {
42768       {
42769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42770       };
42771     } catch (Dali::DaliException e) {
42772       {
42773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42774       };
42775     } catch (...) {
42776       {
42777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42778       };
42779     }
42780   }
42781
42782   jresult = (int)result;
42783   return jresult;
42784 }
42785
42786
42787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42788   int jresult ;
42789   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42790   Dali::AlphaFunction::Mode result;
42791
42792   arg1 = (Dali::AlphaFunction *)jarg1;
42793   {
42794     try {
42795       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42796     } catch (std::out_of_range& e) {
42797       {
42798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42799       };
42800     } catch (std::exception& e) {
42801       {
42802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42803       };
42804     } catch (Dali::DaliException e) {
42805       {
42806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42807       };
42808     } catch (...) {
42809       {
42810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42811       };
42812     }
42813   }
42814
42815   jresult = (int)result;
42816   return jresult;
42817 }
42818
42819
42820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42821   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42822
42823   arg1 = (Dali::AlphaFunction *)jarg1;
42824   {
42825     try {
42826       delete arg1;
42827     } catch (std::out_of_range& e) {
42828       {
42829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42830       };
42831     } catch (std::exception& e) {
42832       {
42833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42834       };
42835     } catch (Dali::DaliException e) {
42836       {
42837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42838       };
42839     } catch (...) {
42840       {
42841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42842       };
42843     }
42844   }
42845
42846 }
42847
42848
42849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42850   void * jresult ;
42851   Dali::KeyFrames result;
42852
42853   {
42854     try {
42855       result = Dali::KeyFrames::New();
42856     } catch (std::out_of_range& e) {
42857       {
42858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42859       };
42860     } catch (std::exception& e) {
42861       {
42862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42863       };
42864     } catch (Dali::DaliException e) {
42865       {
42866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42867       };
42868     } catch (...) {
42869       {
42870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42871       };
42872     }
42873   }
42874
42875   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42876   return jresult;
42877 }
42878
42879
42880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42881   void * jresult ;
42882   Dali::BaseHandle arg1 ;
42883   Dali::BaseHandle *argp1 ;
42884   Dali::KeyFrames result;
42885
42886   argp1 = (Dali::BaseHandle *)jarg1;
42887   if (!argp1) {
42888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42889     return 0;
42890   }
42891   arg1 = *argp1;
42892   {
42893     try {
42894       result = Dali::KeyFrames::DownCast(arg1);
42895     } catch (std::out_of_range& e) {
42896       {
42897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42898       };
42899     } catch (std::exception& e) {
42900       {
42901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42902       };
42903     } catch (Dali::DaliException e) {
42904       {
42905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42906       };
42907     } catch (...) {
42908       {
42909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42910       };
42911     }
42912   }
42913
42914   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42915   return jresult;
42916 }
42917
42918
42919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42920   void * jresult ;
42921   Dali::KeyFrames *result = 0 ;
42922
42923   {
42924     try {
42925       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42926     } catch (std::out_of_range& e) {
42927       {
42928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (std::exception& e) {
42931       {
42932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (Dali::DaliException e) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42937       };
42938     } catch (...) {
42939       {
42940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42941       };
42942     }
42943   }
42944
42945   jresult = (void *)result;
42946   return jresult;
42947 }
42948
42949
42950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42951   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42952
42953   arg1 = (Dali::KeyFrames *)jarg1;
42954   {
42955     try {
42956       delete arg1;
42957     } catch (std::out_of_range& e) {
42958       {
42959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42960       };
42961     } catch (std::exception& e) {
42962       {
42963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42964       };
42965     } catch (Dali::DaliException e) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42968       };
42969     } catch (...) {
42970       {
42971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42972       };
42973     }
42974   }
42975
42976 }
42977
42978
42979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42980   void * jresult ;
42981   Dali::KeyFrames *arg1 = 0 ;
42982   Dali::KeyFrames *result = 0 ;
42983
42984   arg1 = (Dali::KeyFrames *)jarg1;
42985   if (!arg1) {
42986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42987     return 0;
42988   }
42989   {
42990     try {
42991       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42992     } catch (std::out_of_range& e) {
42993       {
42994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42995       };
42996     } catch (std::exception& e) {
42997       {
42998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42999       };
43000     } catch (Dali::DaliException e) {
43001       {
43002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43003       };
43004     } catch (...) {
43005       {
43006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43007       };
43008     }
43009   }
43010
43011   jresult = (void *)result;
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43017   void * jresult ;
43018   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43019   Dali::KeyFrames *arg2 = 0 ;
43020   Dali::KeyFrames *result = 0 ;
43021
43022   arg1 = (Dali::KeyFrames *)jarg1;
43023   arg2 = (Dali::KeyFrames *)jarg2;
43024   if (!arg2) {
43025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43026     return 0;
43027   }
43028   {
43029     try {
43030       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43031     } catch (std::out_of_range& e) {
43032       {
43033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (std::exception& e) {
43036       {
43037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (Dali::DaliException e) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43042       };
43043     } catch (...) {
43044       {
43045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43046       };
43047     }
43048   }
43049
43050   jresult = (void *)result;
43051   return jresult;
43052 }
43053
43054
43055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43056   int jresult ;
43057   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43058   Dali::Property::Type result;
43059
43060   arg1 = (Dali::KeyFrames *)jarg1;
43061   {
43062     try {
43063       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43064     } catch (std::out_of_range& e) {
43065       {
43066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43067       };
43068     } catch (std::exception& e) {
43069       {
43070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43071       };
43072     } catch (Dali::DaliException e) {
43073       {
43074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43075       };
43076     } catch (...) {
43077       {
43078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43079       };
43080     }
43081   }
43082
43083   jresult = (int)result;
43084   return jresult;
43085 }
43086
43087
43088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43089   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43090   float arg2 ;
43091   Dali::Property::Value arg3 ;
43092   Dali::Property::Value *argp3 ;
43093
43094   arg1 = (Dali::KeyFrames *)jarg1;
43095   arg2 = (float)jarg2;
43096   argp3 = (Dali::Property::Value *)jarg3;
43097   if (!argp3) {
43098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43099     return ;
43100   }
43101   arg3 = *argp3;
43102   {
43103     try {
43104       (arg1)->Add(arg2,arg3);
43105     } catch (std::out_of_range& e) {
43106       {
43107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43108       };
43109     } catch (std::exception& e) {
43110       {
43111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43112       };
43113     } catch (Dali::DaliException e) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43120       };
43121     }
43122   }
43123
43124 }
43125
43126
43127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43128   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43129   float arg2 ;
43130   Dali::Property::Value arg3 ;
43131   Dali::AlphaFunction arg4 ;
43132   Dali::Property::Value *argp3 ;
43133   Dali::AlphaFunction *argp4 ;
43134
43135   arg1 = (Dali::KeyFrames *)jarg1;
43136   arg2 = (float)jarg2;
43137   argp3 = (Dali::Property::Value *)jarg3;
43138   if (!argp3) {
43139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43140     return ;
43141   }
43142   arg3 = *argp3;
43143   argp4 = (Dali::AlphaFunction *)jarg4;
43144   if (!argp4) {
43145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43146     return ;
43147   }
43148   arg4 = *argp4;
43149   {
43150     try {
43151       (arg1)->Add(arg2,arg3,arg4);
43152     } catch (std::out_of_range& e) {
43153       {
43154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43155       };
43156     } catch (std::exception& e) {
43157       {
43158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43159       };
43160     } catch (Dali::DaliException e) {
43161       {
43162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43163       };
43164     } catch (...) {
43165       {
43166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43167       };
43168     }
43169   }
43170
43171 }
43172
43173
43174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43175   int jresult ;
43176   int result;
43177
43178   result = (int)Dali::Path::Property::POINTS;
43179   jresult = (int)result;
43180   return jresult;
43181 }
43182
43183
43184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43185   int jresult ;
43186   int result;
43187
43188   result = (int)Dali::Path::Property::CONTROL_POINTS;
43189   jresult = (int)result;
43190   return jresult;
43191 }
43192
43193
43194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43195   void * jresult ;
43196   Dali::Path::Property *result = 0 ;
43197
43198   {
43199     try {
43200       result = (Dali::Path::Property *)new Dali::Path::Property();
43201     } catch (std::out_of_range& e) {
43202       {
43203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (std::exception& e) {
43206       {
43207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (Dali::DaliException e) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43212       };
43213     } catch (...) {
43214       {
43215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43216       };
43217     }
43218   }
43219
43220   jresult = (void *)result;
43221   return jresult;
43222 }
43223
43224
43225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43226   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43227
43228   arg1 = (Dali::Path::Property *)jarg1;
43229   {
43230     try {
43231       delete arg1;
43232     } catch (std::out_of_range& e) {
43233       {
43234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43235       };
43236     } catch (std::exception& e) {
43237       {
43238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43239       };
43240     } catch (Dali::DaliException e) {
43241       {
43242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43243       };
43244     } catch (...) {
43245       {
43246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43247       };
43248     }
43249   }
43250
43251 }
43252
43253
43254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43255   void * jresult ;
43256   Dali::Path result;
43257
43258   {
43259     try {
43260       result = Dali::Path::New();
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 = new Dali::Path((const Dali::Path &)result);
43281   return jresult;
43282 }
43283
43284
43285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43286   void * jresult ;
43287   Dali::BaseHandle arg1 ;
43288   Dali::BaseHandle *argp1 ;
43289   Dali::Path result;
43290
43291   argp1 = (Dali::BaseHandle *)jarg1;
43292   if (!argp1) {
43293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43294     return 0;
43295   }
43296   arg1 = *argp1;
43297   {
43298     try {
43299       result = Dali::Path::DownCast(arg1);
43300     } catch (std::out_of_range& e) {
43301       {
43302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43303       };
43304     } catch (std::exception& e) {
43305       {
43306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43307       };
43308     } catch (Dali::DaliException e) {
43309       {
43310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43311       };
43312     } catch (...) {
43313       {
43314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43315       };
43316     }
43317   }
43318
43319   jresult = new Dali::Path((const Dali::Path &)result);
43320   return jresult;
43321 }
43322
43323
43324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43325   void * jresult ;
43326   Dali::Path *result = 0 ;
43327
43328   {
43329     try {
43330       result = (Dali::Path *)new Dali::Path();
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43338       };
43339     } catch (Dali::DaliException e) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43342       };
43343     } catch (...) {
43344       {
43345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43346       };
43347     }
43348   }
43349
43350   jresult = (void *)result;
43351   return jresult;
43352 }
43353
43354
43355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43356   Dali::Path *arg1 = (Dali::Path *) 0 ;
43357
43358   arg1 = (Dali::Path *)jarg1;
43359   {
43360     try {
43361       delete arg1;
43362     } catch (std::out_of_range& e) {
43363       {
43364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43365       };
43366     } catch (std::exception& e) {
43367       {
43368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43369       };
43370     } catch (Dali::DaliException e) {
43371       {
43372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43373       };
43374     } catch (...) {
43375       {
43376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43377       };
43378     }
43379   }
43380
43381 }
43382
43383
43384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43385   void * jresult ;
43386   Dali::Path *arg1 = 0 ;
43387   Dali::Path *result = 0 ;
43388
43389   arg1 = (Dali::Path *)jarg1;
43390   if (!arg1) {
43391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43392     return 0;
43393   }
43394   {
43395     try {
43396       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
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_Path_Assign(void * jarg1, void * jarg2) {
43422   void * jresult ;
43423   Dali::Path *arg1 = (Dali::Path *) 0 ;
43424   Dali::Path *arg2 = 0 ;
43425   Dali::Path *result = 0 ;
43426
43427   arg1 = (Dali::Path *)jarg1;
43428   arg2 = (Dali::Path *)jarg2;
43429   if (!arg2) {
43430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43431     return 0;
43432   }
43433   {
43434     try {
43435       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43436     } catch (std::out_of_range& e) {
43437       {
43438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43439       };
43440     } catch (std::exception& e) {
43441       {
43442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43443       };
43444     } catch (Dali::DaliException e) {
43445       {
43446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43447       };
43448     } catch (...) {
43449       {
43450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43451       };
43452     }
43453   }
43454
43455   jresult = (void *)result;
43456   return jresult;
43457 }
43458
43459
43460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43461   Dali::Path *arg1 = (Dali::Path *) 0 ;
43462   Dali::Vector3 *arg2 = 0 ;
43463
43464   arg1 = (Dali::Path *)jarg1;
43465   arg2 = (Dali::Vector3 *)jarg2;
43466   if (!arg2) {
43467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43468     return ;
43469   }
43470   {
43471     try {
43472       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43473     } catch (std::out_of_range& e) {
43474       {
43475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43476       };
43477     } catch (std::exception& e) {
43478       {
43479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43480       };
43481     } catch (Dali::DaliException e) {
43482       {
43483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43484       };
43485     } catch (...) {
43486       {
43487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43488       };
43489     }
43490   }
43491
43492 }
43493
43494
43495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43496   Dali::Path *arg1 = (Dali::Path *) 0 ;
43497   Dali::Vector3 *arg2 = 0 ;
43498
43499   arg1 = (Dali::Path *)jarg1;
43500   arg2 = (Dali::Vector3 *)jarg2;
43501   if (!arg2) {
43502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43503     return ;
43504   }
43505   {
43506     try {
43507       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43508     } catch (std::out_of_range& e) {
43509       {
43510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43511       };
43512     } catch (std::exception& e) {
43513       {
43514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43515       };
43516     } catch (Dali::DaliException e) {
43517       {
43518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43519       };
43520     } catch (...) {
43521       {
43522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43523       };
43524     }
43525   }
43526
43527 }
43528
43529
43530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43531   Dali::Path *arg1 = (Dali::Path *) 0 ;
43532   float arg2 ;
43533
43534   arg1 = (Dali::Path *)jarg1;
43535   arg2 = (float)jarg2;
43536   {
43537     try {
43538       (arg1)->GenerateControlPoints(arg2);
43539     } catch (std::out_of_range& e) {
43540       {
43541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43542       };
43543     } catch (std::exception& e) {
43544       {
43545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43546       };
43547     } catch (Dali::DaliException e) {
43548       {
43549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43550       };
43551     } catch (...) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43554       };
43555     }
43556   }
43557
43558 }
43559
43560
43561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43562   Dali::Path *arg1 = (Dali::Path *) 0 ;
43563   float arg2 ;
43564   Dali::Vector3 *arg3 = 0 ;
43565   Dali::Vector3 *arg4 = 0 ;
43566
43567   arg1 = (Dali::Path *)jarg1;
43568   arg2 = (float)jarg2;
43569   arg3 = (Dali::Vector3 *)jarg3;
43570   if (!arg3) {
43571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43572     return ;
43573   }
43574   arg4 = (Dali::Vector3 *)jarg4;
43575   if (!arg4) {
43576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43577     return ;
43578   }
43579   {
43580     try {
43581       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43582     } catch (std::out_of_range& e) {
43583       {
43584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43585       };
43586     } catch (std::exception& e) {
43587       {
43588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43589       };
43590     } catch (Dali::DaliException e) {
43591       {
43592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43593       };
43594     } catch (...) {
43595       {
43596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43597       };
43598     }
43599   }
43600
43601 }
43602
43603
43604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43605   void * jresult ;
43606   Dali::Path *arg1 = (Dali::Path *) 0 ;
43607   size_t arg2 ;
43608   Dali::Vector3 *result = 0 ;
43609
43610   arg1 = (Dali::Path *)jarg1;
43611   arg2 = (size_t)jarg2;
43612   {
43613     try {
43614       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43615     } catch (std::out_of_range& e) {
43616       {
43617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43618       };
43619     } catch (std::exception& e) {
43620       {
43621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43622       };
43623     } catch (Dali::DaliException e) {
43624       {
43625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43626       };
43627     } catch (...) {
43628       {
43629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43630       };
43631     }
43632   }
43633
43634   jresult = (void *)result;
43635   return jresult;
43636 }
43637
43638
43639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43640   void * jresult ;
43641   Dali::Path *arg1 = (Dali::Path *) 0 ;
43642   size_t arg2 ;
43643   Dali::Vector3 *result = 0 ;
43644
43645   arg1 = (Dali::Path *)jarg1;
43646   arg2 = (size_t)jarg2;
43647   {
43648     try {
43649       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43675   unsigned long jresult ;
43676   Dali::Path *arg1 = (Dali::Path *) 0 ;
43677   size_t result;
43678
43679   arg1 = (Dali::Path *)jarg1;
43680   {
43681     try {
43682       result = ((Dali::Path const *)arg1)->GetPointCount();
43683     } catch (std::out_of_range& e) {
43684       {
43685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (std::exception& e) {
43688       {
43689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (Dali::DaliException e) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43694       };
43695     } catch (...) {
43696       {
43697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43698       };
43699     }
43700   }
43701
43702   jresult = (unsigned long)result;
43703   return jresult;
43704 }
43705
43706
43707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43708   void * jresult ;
43709   float arg1 ;
43710   Dali::TimePeriod *result = 0 ;
43711
43712   arg1 = (float)jarg1;
43713   {
43714     try {
43715       result = (Dali::TimePeriod *)new Dali::TimePeriod(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_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43741   void * jresult ;
43742   float arg1 ;
43743   float arg2 ;
43744   Dali::TimePeriod *result = 0 ;
43745
43746   arg1 = (float)jarg1;
43747   arg2 = (float)jarg2;
43748   {
43749     try {
43750       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43751     } catch (std::out_of_range& e) {
43752       {
43753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43754       };
43755     } catch (std::exception& e) {
43756       {
43757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43758       };
43759     } catch (Dali::DaliException e) {
43760       {
43761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43762       };
43763     } catch (...) {
43764       {
43765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43766       };
43767     }
43768   }
43769
43770   jresult = (void *)result;
43771   return jresult;
43772 }
43773
43774
43775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43776   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43777
43778   arg1 = (Dali::TimePeriod *)jarg1;
43779   {
43780     try {
43781       delete arg1;
43782     } catch (std::out_of_range& e) {
43783       {
43784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43785       };
43786     } catch (std::exception& e) {
43787       {
43788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43789       };
43790     } catch (Dali::DaliException e) {
43791       {
43792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43793       };
43794     } catch (...) {
43795       {
43796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43797       };
43798     }
43799   }
43800
43801 }
43802
43803
43804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43805   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43806   float arg2 ;
43807
43808   arg1 = (Dali::TimePeriod *)jarg1;
43809   arg2 = (float)jarg2;
43810   if (arg1) (arg1)->delaySeconds = arg2;
43811 }
43812
43813
43814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43815   float jresult ;
43816   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43817   float result;
43818
43819   arg1 = (Dali::TimePeriod *)jarg1;
43820   result = (float) ((arg1)->delaySeconds);
43821   jresult = result;
43822   return jresult;
43823 }
43824
43825
43826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43827   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43828   float arg2 ;
43829
43830   arg1 = (Dali::TimePeriod *)jarg1;
43831   arg2 = (float)jarg2;
43832   if (arg1) (arg1)->durationSeconds = arg2;
43833 }
43834
43835
43836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43837   float jresult ;
43838   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43839   float result;
43840
43841   arg1 = (Dali::TimePeriod *)jarg1;
43842   result = (float) ((arg1)->durationSeconds);
43843   jresult = result;
43844   return jresult;
43845 }
43846
43847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43848   int jresult ;
43849   int result;
43850
43851   result = (int)Dali::LinearConstrainer::Property::VALUE;
43852   jresult = (int)result;
43853   return jresult;
43854 }
43855
43856
43857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43858   int jresult ;
43859   int result;
43860
43861   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43862   jresult = (int)result;
43863   return jresult;
43864 }
43865
43866
43867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43868   void * jresult ;
43869   Dali::LinearConstrainer::Property *result = 0 ;
43870
43871   {
43872     try {
43873       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43874     } catch (std::out_of_range& e) {
43875       {
43876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43877       };
43878     } catch (std::exception& e) {
43879       {
43880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43881       };
43882     } catch (Dali::DaliException e) {
43883       {
43884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43885       };
43886     } catch (...) {
43887       {
43888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43889       };
43890     }
43891   }
43892
43893   jresult = (void *)result;
43894   return jresult;
43895 }
43896
43897
43898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43899   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43900
43901   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43902   {
43903     try {
43904       delete arg1;
43905     } catch (std::out_of_range& e) {
43906       {
43907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43908       };
43909     } catch (std::exception& e) {
43910       {
43911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43912       };
43913     } catch (Dali::DaliException e) {
43914       {
43915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43916       };
43917     } catch (...) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43920       };
43921     }
43922   }
43923
43924 }
43925
43926
43927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43928   void * jresult ;
43929   Dali::LinearConstrainer result;
43930
43931   {
43932     try {
43933       result = Dali::LinearConstrainer::New();
43934     } catch (std::out_of_range& e) {
43935       {
43936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43937       };
43938     } catch (std::exception& e) {
43939       {
43940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43941       };
43942     } catch (Dali::DaliException e) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43945       };
43946     } catch (...) {
43947       {
43948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43949       };
43950     }
43951   }
43952
43953   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43954   return jresult;
43955 }
43956
43957
43958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43959   void * jresult ;
43960   Dali::BaseHandle arg1 ;
43961   Dali::BaseHandle *argp1 ;
43962   Dali::LinearConstrainer result;
43963
43964   argp1 = (Dali::BaseHandle *)jarg1;
43965   if (!argp1) {
43966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43967     return 0;
43968   }
43969   arg1 = *argp1;
43970   {
43971     try {
43972       result = Dali::LinearConstrainer::DownCast(arg1);
43973     } catch (std::out_of_range& e) {
43974       {
43975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43976       };
43977     } catch (std::exception& e) {
43978       {
43979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43980       };
43981     } catch (Dali::DaliException e) {
43982       {
43983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43984       };
43985     } catch (...) {
43986       {
43987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43988       };
43989     }
43990   }
43991
43992   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43993   return jresult;
43994 }
43995
43996
43997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43998   void * jresult ;
43999   Dali::LinearConstrainer *result = 0 ;
44000
44001   {
44002     try {
44003       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44004     } catch (std::out_of_range& e) {
44005       {
44006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44007       };
44008     } catch (std::exception& e) {
44009       {
44010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44011       };
44012     } catch (Dali::DaliException e) {
44013       {
44014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44015       };
44016     } catch (...) {
44017       {
44018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44019       };
44020     }
44021   }
44022
44023   jresult = (void *)result;
44024   return jresult;
44025 }
44026
44027
44028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44029   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44030
44031   arg1 = (Dali::LinearConstrainer *)jarg1;
44032   {
44033     try {
44034       delete arg1;
44035     } catch (std::out_of_range& e) {
44036       {
44037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44038       };
44039     } catch (std::exception& e) {
44040       {
44041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44042       };
44043     } catch (Dali::DaliException e) {
44044       {
44045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44046       };
44047     } catch (...) {
44048       {
44049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44050       };
44051     }
44052   }
44053
44054 }
44055
44056
44057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44058   void * jresult ;
44059   Dali::LinearConstrainer *arg1 = 0 ;
44060   Dali::LinearConstrainer *result = 0 ;
44061
44062   arg1 = (Dali::LinearConstrainer *)jarg1;
44063   if (!arg1) {
44064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44065     return 0;
44066   }
44067   {
44068     try {
44069       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44070     } catch (std::out_of_range& e) {
44071       {
44072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44073       };
44074     } catch (std::exception& e) {
44075       {
44076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44077       };
44078     } catch (Dali::DaliException e) {
44079       {
44080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44081       };
44082     } catch (...) {
44083       {
44084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44085       };
44086     }
44087   }
44088
44089   jresult = (void *)result;
44090   return jresult;
44091 }
44092
44093
44094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44095   void * jresult ;
44096   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44097   Dali::LinearConstrainer *arg2 = 0 ;
44098   Dali::LinearConstrainer *result = 0 ;
44099
44100   arg1 = (Dali::LinearConstrainer *)jarg1;
44101   arg2 = (Dali::LinearConstrainer *)jarg2;
44102   if (!arg2) {
44103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44104     return 0;
44105   }
44106   {
44107     try {
44108       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44109     } catch (std::out_of_range& e) {
44110       {
44111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44112       };
44113     } catch (std::exception& e) {
44114       {
44115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44116       };
44117     } catch (Dali::DaliException e) {
44118       {
44119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44120       };
44121     } catch (...) {
44122       {
44123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44124       };
44125     }
44126   }
44127
44128   jresult = (void *)result;
44129   return jresult;
44130 }
44131
44132
44133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44134   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44135   SwigValueWrapper< Dali::Property > arg2 ;
44136   SwigValueWrapper< Dali::Property > arg3 ;
44137   Dali::Vector2 *arg4 = 0 ;
44138   Dali::Vector2 *arg5 = 0 ;
44139   Dali::Property *argp2 ;
44140   Dali::Property *argp3 ;
44141
44142   arg1 = (Dali::LinearConstrainer *)jarg1;
44143   argp2 = (Dali::Property *)jarg2;
44144   if (!argp2) {
44145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44146     return ;
44147   }
44148   arg2 = *argp2;
44149   argp3 = (Dali::Property *)jarg3;
44150   if (!argp3) {
44151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44152     return ;
44153   }
44154   arg3 = *argp3;
44155   arg4 = (Dali::Vector2 *)jarg4;
44156   if (!arg4) {
44157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44158     return ;
44159   }
44160   arg5 = (Dali::Vector2 *)jarg5;
44161   if (!arg5) {
44162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44163     return ;
44164   }
44165   {
44166     try {
44167       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44168     } catch (std::out_of_range& e) {
44169       {
44170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44171       };
44172     } catch (std::exception& e) {
44173       {
44174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44175       };
44176     } catch (Dali::DaliException e) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44179       };
44180     } catch (...) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44183       };
44184     }
44185   }
44186
44187 }
44188
44189
44190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44191   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44192   SwigValueWrapper< Dali::Property > arg2 ;
44193   SwigValueWrapper< Dali::Property > arg3 ;
44194   Dali::Vector2 *arg4 = 0 ;
44195   Dali::Property *argp2 ;
44196   Dali::Property *argp3 ;
44197
44198   arg1 = (Dali::LinearConstrainer *)jarg1;
44199   argp2 = (Dali::Property *)jarg2;
44200   if (!argp2) {
44201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44202     return ;
44203   }
44204   arg2 = *argp2;
44205   argp3 = (Dali::Property *)jarg3;
44206   if (!argp3) {
44207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44208     return ;
44209   }
44210   arg3 = *argp3;
44211   arg4 = (Dali::Vector2 *)jarg4;
44212   if (!arg4) {
44213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44214     return ;
44215   }
44216   {
44217     try {
44218       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44219     } catch (std::out_of_range& e) {
44220       {
44221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44222       };
44223     } catch (std::exception& e) {
44224       {
44225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44226       };
44227     } catch (Dali::DaliException e) {
44228       {
44229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44230       };
44231     } catch (...) {
44232       {
44233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44234       };
44235     }
44236   }
44237
44238 }
44239
44240
44241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44242   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44243   Dali::Handle *arg2 = 0 ;
44244
44245   arg1 = (Dali::LinearConstrainer *)jarg1;
44246   arg2 = (Dali::Handle *)jarg2;
44247   if (!arg2) {
44248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44249     return ;
44250   }
44251   {
44252     try {
44253       (arg1)->Remove(*arg2);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44261       };
44262     } catch (Dali::DaliException e) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44265       };
44266     } catch (...) {
44267       {
44268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44269       };
44270     }
44271   }
44272
44273 }
44274
44275
44276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44277   int jresult ;
44278   int result;
44279
44280   result = (int)Dali::PathConstrainer::Property::FORWARD;
44281   jresult = (int)result;
44282   return jresult;
44283 }
44284
44285
44286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44287   int jresult ;
44288   int result;
44289
44290   result = (int)Dali::PathConstrainer::Property::POINTS;
44291   jresult = (int)result;
44292   return jresult;
44293 }
44294
44295
44296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44297   int jresult ;
44298   int result;
44299
44300   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44301   jresult = (int)result;
44302   return jresult;
44303 }
44304
44305
44306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44307   void * jresult ;
44308   Dali::PathConstrainer::Property *result = 0 ;
44309
44310   {
44311     try {
44312       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44313     } catch (std::out_of_range& e) {
44314       {
44315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44316       };
44317     } catch (std::exception& e) {
44318       {
44319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44320       };
44321     } catch (Dali::DaliException e) {
44322       {
44323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44324       };
44325     } catch (...) {
44326       {
44327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44328       };
44329     }
44330   }
44331
44332   jresult = (void *)result;
44333   return jresult;
44334 }
44335
44336
44337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44338   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44339
44340   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44341   {
44342     try {
44343       delete arg1;
44344     } catch (std::out_of_range& e) {
44345       {
44346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44347       };
44348     } catch (std::exception& e) {
44349       {
44350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44351       };
44352     } catch (Dali::DaliException e) {
44353       {
44354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44355       };
44356     } catch (...) {
44357       {
44358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44359       };
44360     }
44361   }
44362
44363 }
44364
44365
44366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44367   void * jresult ;
44368   Dali::PathConstrainer result;
44369
44370   {
44371     try {
44372       result = Dali::PathConstrainer::New();
44373     } catch (std::out_of_range& e) {
44374       {
44375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44376       };
44377     } catch (std::exception& e) {
44378       {
44379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44380       };
44381     } catch (Dali::DaliException e) {
44382       {
44383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44384       };
44385     } catch (...) {
44386       {
44387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44388       };
44389     }
44390   }
44391
44392   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44393   return jresult;
44394 }
44395
44396
44397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44398   void * jresult ;
44399   Dali::BaseHandle arg1 ;
44400   Dali::BaseHandle *argp1 ;
44401   Dali::PathConstrainer result;
44402
44403   argp1 = (Dali::BaseHandle *)jarg1;
44404   if (!argp1) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44406     return 0;
44407   }
44408   arg1 = *argp1;
44409   {
44410     try {
44411       result = Dali::PathConstrainer::DownCast(arg1);
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44419       };
44420     } catch (Dali::DaliException e) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44427       };
44428     }
44429   }
44430
44431   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44437   void * jresult ;
44438   Dali::PathConstrainer *result = 0 ;
44439
44440   {
44441     try {
44442       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44443     } catch (std::out_of_range& e) {
44444       {
44445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44446       };
44447     } catch (std::exception& e) {
44448       {
44449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44450       };
44451     } catch (Dali::DaliException e) {
44452       {
44453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44454       };
44455     } catch (...) {
44456       {
44457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44458       };
44459     }
44460   }
44461
44462   jresult = (void *)result;
44463   return jresult;
44464 }
44465
44466
44467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44468   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44469
44470   arg1 = (Dali::PathConstrainer *)jarg1;
44471   {
44472     try {
44473       delete arg1;
44474     } catch (std::out_of_range& e) {
44475       {
44476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (std::exception& e) {
44479       {
44480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (Dali::DaliException e) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44485       };
44486     } catch (...) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44489       };
44490     }
44491   }
44492
44493 }
44494
44495
44496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44497   void * jresult ;
44498   Dali::PathConstrainer *arg1 = 0 ;
44499   Dali::PathConstrainer *result = 0 ;
44500
44501   arg1 = (Dali::PathConstrainer *)jarg1;
44502   if (!arg1) {
44503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44504     return 0;
44505   }
44506   {
44507     try {
44508       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44509     } catch (std::out_of_range& e) {
44510       {
44511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44512       };
44513     } catch (std::exception& e) {
44514       {
44515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44516       };
44517     } catch (Dali::DaliException e) {
44518       {
44519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44520       };
44521     } catch (...) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44524       };
44525     }
44526   }
44527
44528   jresult = (void *)result;
44529   return jresult;
44530 }
44531
44532
44533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44534   void * jresult ;
44535   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44536   Dali::PathConstrainer *arg2 = 0 ;
44537   Dali::PathConstrainer *result = 0 ;
44538
44539   arg1 = (Dali::PathConstrainer *)jarg1;
44540   arg2 = (Dali::PathConstrainer *)jarg2;
44541   if (!arg2) {
44542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44543     return 0;
44544   }
44545   {
44546     try {
44547       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44548     } catch (std::out_of_range& e) {
44549       {
44550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44551       };
44552     } catch (std::exception& e) {
44553       {
44554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44555       };
44556     } catch (Dali::DaliException e) {
44557       {
44558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44559       };
44560     } catch (...) {
44561       {
44562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44563       };
44564     }
44565   }
44566
44567   jresult = (void *)result;
44568   return jresult;
44569 }
44570
44571
44572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44573   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44574   SwigValueWrapper< Dali::Property > arg2 ;
44575   SwigValueWrapper< Dali::Property > arg3 ;
44576   Dali::Vector2 *arg4 = 0 ;
44577   Dali::Vector2 *arg5 = 0 ;
44578   Dali::Property *argp2 ;
44579   Dali::Property *argp3 ;
44580
44581   arg1 = (Dali::PathConstrainer *)jarg1;
44582   argp2 = (Dali::Property *)jarg2;
44583   if (!argp2) {
44584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44585     return ;
44586   }
44587   arg2 = *argp2;
44588   argp3 = (Dali::Property *)jarg3;
44589   if (!argp3) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44591     return ;
44592   }
44593   arg3 = *argp3;
44594   arg4 = (Dali::Vector2 *)jarg4;
44595   if (!arg4) {
44596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44597     return ;
44598   }
44599   arg5 = (Dali::Vector2 *)jarg5;
44600   if (!arg5) {
44601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44602     return ;
44603   }
44604   {
44605     try {
44606       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44607     } catch (std::out_of_range& e) {
44608       {
44609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44610       };
44611     } catch (std::exception& e) {
44612       {
44613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44614       };
44615     } catch (Dali::DaliException e) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44618       };
44619     } catch (...) {
44620       {
44621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44622       };
44623     }
44624   }
44625
44626 }
44627
44628
44629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44630   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44631   SwigValueWrapper< Dali::Property > arg2 ;
44632   SwigValueWrapper< Dali::Property > arg3 ;
44633   Dali::Vector2 *arg4 = 0 ;
44634   Dali::Property *argp2 ;
44635   Dali::Property *argp3 ;
44636
44637   arg1 = (Dali::PathConstrainer *)jarg1;
44638   argp2 = (Dali::Property *)jarg2;
44639   if (!argp2) {
44640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44641     return ;
44642   }
44643   arg2 = *argp2;
44644   argp3 = (Dali::Property *)jarg3;
44645   if (!argp3) {
44646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44647     return ;
44648   }
44649   arg3 = *argp3;
44650   arg4 = (Dali::Vector2 *)jarg4;
44651   if (!arg4) {
44652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44653     return ;
44654   }
44655   {
44656     try {
44657       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44658     } catch (std::out_of_range& e) {
44659       {
44660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44661       };
44662     } catch (std::exception& e) {
44663       {
44664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44665       };
44666     } catch (Dali::DaliException e) {
44667       {
44668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44669       };
44670     } catch (...) {
44671       {
44672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44673       };
44674     }
44675   }
44676
44677 }
44678
44679
44680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44681   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44682   Dali::Handle *arg2 = 0 ;
44683
44684   arg1 = (Dali::PathConstrainer *)jarg1;
44685   arg2 = (Dali::Handle *)jarg2;
44686   if (!arg2) {
44687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44688     return ;
44689   }
44690   {
44691     try {
44692       (arg1)->Remove(*arg2);
44693     } catch (std::out_of_range& e) {
44694       {
44695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44696       };
44697     } catch (std::exception& e) {
44698       {
44699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44700       };
44701     } catch (Dali::DaliException e) {
44702       {
44703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44704       };
44705     } catch (...) {
44706       {
44707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44708       };
44709     }
44710   }
44711
44712 }
44713
44714
44715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44716   int jresult ;
44717   Dali::FittingMode::Type result;
44718
44719   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44720   jresult = (int)result;
44721   return jresult;
44722 }
44723
44724
44725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44726   int jresult ;
44727   Dali::SamplingMode::Type result;
44728
44729   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44730   jresult = (int)result;
44731   return jresult;
44732 }
44733
44734
44735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44736   unsigned int jresult ;
44737   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44738   bool result;
44739
44740   arg1 = (Dali::NativeImageInterface *)jarg1;
44741   {
44742     try {
44743       result = (bool)(arg1)->CreateResource();
44744     } catch (std::out_of_range& e) {
44745       {
44746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44747       };
44748     } catch (std::exception& e) {
44749       {
44750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (Dali::DaliException e) {
44753       {
44754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762
44763   jresult = result;
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44769   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44770
44771   arg1 = (Dali::NativeImageInterface *)jarg1;
44772   {
44773     try {
44774       (arg1)->DestroyResource();
44775     } catch (std::out_of_range& e) {
44776       {
44777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44778       };
44779     } catch (std::exception& e) {
44780       {
44781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44782       };
44783     } catch (Dali::DaliException e) {
44784       {
44785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44786       };
44787     } catch (...) {
44788       {
44789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44790       };
44791     }
44792   }
44793
44794 }
44795
44796
44797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44798   unsigned int jresult ;
44799   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44800   unsigned int result;
44801
44802   arg1 = (Dali::NativeImageInterface *)jarg1;
44803   {
44804     try {
44805       result = (unsigned int)(arg1)->TargetTexture();
44806     } catch (std::out_of_range& e) {
44807       {
44808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44809       };
44810     } catch (std::exception& e) {
44811       {
44812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44813       };
44814     } catch (Dali::DaliException e) {
44815       {
44816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44817       };
44818     } catch (...) {
44819       {
44820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44821       };
44822     }
44823   }
44824
44825   jresult = result;
44826   return jresult;
44827 }
44828
44829
44830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44831   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44832
44833   arg1 = (Dali::NativeImageInterface *)jarg1;
44834   {
44835     try {
44836       (arg1)->PrepareTexture();
44837     } catch (std::out_of_range& e) {
44838       {
44839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44840       };
44841     } catch (std::exception& e) {
44842       {
44843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44844       };
44845     } catch (Dali::DaliException e) {
44846       {
44847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44848       };
44849     } catch (...) {
44850       {
44851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44852       };
44853     }
44854   }
44855
44856 }
44857
44858
44859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44860   unsigned int jresult ;
44861   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44862   unsigned int result;
44863
44864   arg1 = (Dali::NativeImageInterface *)jarg1;
44865   {
44866     try {
44867       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44868     } catch (std::out_of_range& e) {
44869       {
44870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44871       };
44872     } catch (std::exception& e) {
44873       {
44874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44875       };
44876     } catch (Dali::DaliException e) {
44877       {
44878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44879       };
44880     } catch (...) {
44881       {
44882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44883       };
44884     }
44885   }
44886
44887   jresult = result;
44888   return jresult;
44889 }
44890
44891
44892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44893   unsigned int jresult ;
44894   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44895   unsigned int result;
44896
44897   arg1 = (Dali::NativeImageInterface *)jarg1;
44898   {
44899     try {
44900       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44901     } catch (std::out_of_range& e) {
44902       {
44903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44904       };
44905     } catch (std::exception& e) {
44906       {
44907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44908       };
44909     } catch (Dali::DaliException e) {
44910       {
44911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44912       };
44913     } catch (...) {
44914       {
44915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44916       };
44917     }
44918   }
44919
44920   jresult = result;
44921   return jresult;
44922 }
44923
44924
44925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44926   unsigned int jresult ;
44927   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44928   bool result;
44929
44930   arg1 = (Dali::NativeImageInterface *)jarg1;
44931   {
44932     try {
44933       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (Dali::DaliException e) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44945       };
44946     } catch (...) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44949       };
44950     }
44951   }
44952
44953   jresult = result;
44954   return jresult;
44955 }
44956
44957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44958   int jresult ;
44959   int result;
44960
44961   result = (int)Dali::CameraActor::Property::TYPE;
44962   jresult = (int)result;
44963   return jresult;
44964 }
44965
44966
44967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44968   int jresult ;
44969   int result;
44970
44971   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44972   jresult = (int)result;
44973   return jresult;
44974 }
44975
44976
44977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44978   int jresult ;
44979   int result;
44980
44981   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44982   jresult = (int)result;
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44988   int jresult ;
44989   int result;
44990
44991   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44992   jresult = (int)result;
44993   return jresult;
44994 }
44995
44996
44997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44998   int jresult ;
44999   int result;
45000
45001   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
45002   jresult = (int)result;
45003   return jresult;
45004 }
45005
45006
45007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
45008   int jresult ;
45009   int result;
45010
45011   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
45012   jresult = (int)result;
45013   return jresult;
45014 }
45015
45016
45017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
45018   int jresult ;
45019   int result;
45020
45021   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
45022   jresult = (int)result;
45023   return jresult;
45024 }
45025
45026
45027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
45028   int jresult ;
45029   int result;
45030
45031   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
45032   jresult = (int)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
45038   int jresult ;
45039   int result;
45040
45041   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
45042   jresult = (int)result;
45043   return jresult;
45044 }
45045
45046
45047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
45048   int jresult ;
45049   int result;
45050
45051   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
45052   jresult = (int)result;
45053   return jresult;
45054 }
45055
45056
45057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
45058   int jresult ;
45059   int result;
45060
45061   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
45062   jresult = (int)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
45068   int jresult ;
45069   int result;
45070
45071   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
45078   int jresult ;
45079   int result;
45080
45081   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
45082   jresult = (int)result;
45083   return jresult;
45084 }
45085
45086
45087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
45088   int jresult ;
45089   int result;
45090
45091   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
45092   jresult = (int)result;
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
45098   void * jresult ;
45099   Dali::CameraActor::Property *result = 0 ;
45100
45101   {
45102     try {
45103       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
45104     } catch (std::out_of_range& e) {
45105       {
45106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45107       };
45108     } catch (std::exception& e) {
45109       {
45110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45111       };
45112     } catch (Dali::DaliException e) {
45113       {
45114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45115       };
45116     } catch (...) {
45117       {
45118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45119       };
45120     }
45121   }
45122
45123   jresult = (void *)result;
45124   return jresult;
45125 }
45126
45127
45128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
45129   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
45130
45131   arg1 = (Dali::CameraActor::Property *)jarg1;
45132   {
45133     try {
45134       delete arg1;
45135     } catch (std::out_of_range& e) {
45136       {
45137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45138       };
45139     } catch (std::exception& e) {
45140       {
45141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45142       };
45143     } catch (Dali::DaliException e) {
45144       {
45145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45146       };
45147     } catch (...) {
45148       {
45149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45150       };
45151     }
45152   }
45153
45154 }
45155
45156
45157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
45158   void * jresult ;
45159   Dali::CameraActor *result = 0 ;
45160
45161   {
45162     try {
45163       result = (Dali::CameraActor *)new Dali::CameraActor();
45164     } catch (std::out_of_range& e) {
45165       {
45166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45167       };
45168     } catch (std::exception& e) {
45169       {
45170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45171       };
45172     } catch (Dali::DaliException e) {
45173       {
45174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45175       };
45176     } catch (...) {
45177       {
45178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45179       };
45180     }
45181   }
45182
45183   jresult = (void *)result;
45184   return jresult;
45185 }
45186
45187
45188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45189   void * jresult ;
45190   Dali::CameraActor result;
45191
45192   {
45193     try {
45194       result = Dali::CameraActor::New();
45195     } catch (std::out_of_range& e) {
45196       {
45197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (std::exception& e) {
45200       {
45201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45202       };
45203     } catch (Dali::DaliException e) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45206       };
45207     } catch (...) {
45208       {
45209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45210       };
45211     }
45212   }
45213
45214   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45215   return jresult;
45216 }
45217
45218
45219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45220   void * jresult ;
45221   Dali::Size *arg1 = 0 ;
45222   Dali::CameraActor result;
45223
45224   arg1 = (Dali::Size *)jarg1;
45225   if (!arg1) {
45226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45227     return 0;
45228   }
45229   {
45230     try {
45231       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (Dali::DaliException e) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45243       };
45244     } catch (...) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45247       };
45248     }
45249   }
45250
45251   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45252   return jresult;
45253 }
45254
45255
45256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45257   void * jresult ;
45258   Dali::BaseHandle arg1 ;
45259   Dali::BaseHandle *argp1 ;
45260   Dali::CameraActor result;
45261
45262   argp1 = (Dali::BaseHandle *)jarg1;
45263   if (!argp1) {
45264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45265     return 0;
45266   }
45267   arg1 = *argp1;
45268   {
45269     try {
45270       result = Dali::CameraActor::DownCast(arg1);
45271     } catch (std::out_of_range& e) {
45272       {
45273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45274       };
45275     } catch (std::exception& e) {
45276       {
45277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45278       };
45279     } catch (Dali::DaliException e) {
45280       {
45281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45282       };
45283     } catch (...) {
45284       {
45285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45286       };
45287     }
45288   }
45289
45290   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45291   return jresult;
45292 }
45293
45294
45295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45296   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45297
45298   arg1 = (Dali::CameraActor *)jarg1;
45299   {
45300     try {
45301       delete arg1;
45302     } catch (std::out_of_range& e) {
45303       {
45304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45305       };
45306     } catch (std::exception& e) {
45307       {
45308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45309       };
45310     } catch (Dali::DaliException e) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45313       };
45314     } catch (...) {
45315       {
45316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45317       };
45318     }
45319   }
45320
45321 }
45322
45323
45324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45325   void * jresult ;
45326   Dali::CameraActor *arg1 = 0 ;
45327   Dali::CameraActor *result = 0 ;
45328
45329   arg1 = (Dali::CameraActor *)jarg1;
45330   if (!arg1) {
45331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45332     return 0;
45333   }
45334   {
45335     try {
45336       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45337     } catch (std::out_of_range& e) {
45338       {
45339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (std::exception& e) {
45342       {
45343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (Dali::DaliException e) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45352       };
45353     }
45354   }
45355
45356   jresult = (void *)result;
45357   return jresult;
45358 }
45359
45360
45361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45362   void * jresult ;
45363   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45364   Dali::CameraActor *arg2 = 0 ;
45365   Dali::CameraActor *result = 0 ;
45366
45367   arg1 = (Dali::CameraActor *)jarg1;
45368   arg2 = (Dali::CameraActor *)jarg2;
45369   if (!arg2) {
45370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45371     return 0;
45372   }
45373   {
45374     try {
45375       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45376     } catch (std::out_of_range& e) {
45377       {
45378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45379       };
45380     } catch (std::exception& e) {
45381       {
45382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45383       };
45384     } catch (Dali::DaliException e) {
45385       {
45386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45387       };
45388     } catch (...) {
45389       {
45390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45391       };
45392     }
45393   }
45394
45395   jresult = (void *)result;
45396   return jresult;
45397 }
45398
45399
45400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45401   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45402   Dali::Camera::Type arg2 ;
45403
45404   arg1 = (Dali::CameraActor *)jarg1;
45405   arg2 = (Dali::Camera::Type)jarg2;
45406   {
45407     try {
45408       (arg1)->SetType(arg2);
45409     } catch (std::out_of_range& e) {
45410       {
45411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45412       };
45413     } catch (std::exception& e) {
45414       {
45415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45416       };
45417     } catch (Dali::DaliException e) {
45418       {
45419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45420       };
45421     } catch (...) {
45422       {
45423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45424       };
45425     }
45426   }
45427
45428 }
45429
45430
45431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45432   int jresult ;
45433   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45434   Dali::Camera::Type result;
45435
45436   arg1 = (Dali::CameraActor *)jarg1;
45437   {
45438     try {
45439       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45440     } catch (std::out_of_range& e) {
45441       {
45442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45443       };
45444     } catch (std::exception& e) {
45445       {
45446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45447       };
45448     } catch (Dali::DaliException e) {
45449       {
45450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45451       };
45452     } catch (...) {
45453       {
45454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45455       };
45456     }
45457   }
45458
45459   jresult = (int)result;
45460   return jresult;
45461 }
45462
45463
45464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45465   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45466   Dali::Camera::ProjectionMode arg2 ;
45467
45468   arg1 = (Dali::CameraActor *)jarg1;
45469   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45470   {
45471     try {
45472       (arg1)->SetProjectionMode(arg2);
45473     } catch (std::out_of_range& e) {
45474       {
45475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45476       };
45477     } catch (std::exception& e) {
45478       {
45479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45480       };
45481     } catch (Dali::DaliException e) {
45482       {
45483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45484       };
45485     } catch (...) {
45486       {
45487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45488       };
45489     }
45490   }
45491
45492 }
45493
45494
45495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45496   int jresult ;
45497   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45498   Dali::Camera::ProjectionMode result;
45499
45500   arg1 = (Dali::CameraActor *)jarg1;
45501   {
45502     try {
45503       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45504     } catch (std::out_of_range& e) {
45505       {
45506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (std::exception& e) {
45509       {
45510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45511       };
45512     } catch (Dali::DaliException e) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45515       };
45516     } catch (...) {
45517       {
45518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45519       };
45520     }
45521   }
45522
45523   jresult = (int)result;
45524   return jresult;
45525 }
45526
45527
45528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45529   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45530   float arg2 ;
45531
45532   arg1 = (Dali::CameraActor *)jarg1;
45533   arg2 = (float)jarg2;
45534   {
45535     try {
45536       (arg1)->SetFieldOfView(arg2);
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (Dali::DaliException e) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45552       };
45553     }
45554   }
45555
45556 }
45557
45558
45559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45560   float jresult ;
45561   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45562   float result;
45563
45564   arg1 = (Dali::CameraActor *)jarg1;
45565   {
45566     try {
45567       result = (float)(arg1)->GetFieldOfView();
45568     } catch (std::out_of_range& e) {
45569       {
45570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45571       };
45572     } catch (std::exception& e) {
45573       {
45574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45575       };
45576     } catch (Dali::DaliException e) {
45577       {
45578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45579       };
45580     } catch (...) {
45581       {
45582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45583       };
45584     }
45585   }
45586
45587   jresult = result;
45588   return jresult;
45589 }
45590
45591
45592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45593   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45594   float arg2 ;
45595
45596   arg1 = (Dali::CameraActor *)jarg1;
45597   arg2 = (float)jarg2;
45598   {
45599     try {
45600       (arg1)->SetAspectRatio(arg2);
45601     } catch (std::out_of_range& e) {
45602       {
45603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45604       };
45605     } catch (std::exception& e) {
45606       {
45607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45608       };
45609     } catch (Dali::DaliException e) {
45610       {
45611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45612       };
45613     } catch (...) {
45614       {
45615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45616       };
45617     }
45618   }
45619
45620 }
45621
45622
45623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45624   float jresult ;
45625   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45626   float result;
45627
45628   arg1 = (Dali::CameraActor *)jarg1;
45629   {
45630     try {
45631       result = (float)(arg1)->GetAspectRatio();
45632     } catch (std::out_of_range& e) {
45633       {
45634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (std::exception& e) {
45637       {
45638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (Dali::DaliException e) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45643       };
45644     } catch (...) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45647       };
45648     }
45649   }
45650
45651   jresult = result;
45652   return jresult;
45653 }
45654
45655
45656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45658   float arg2 ;
45659
45660   arg1 = (Dali::CameraActor *)jarg1;
45661   arg2 = (float)jarg2;
45662   {
45663     try {
45664       (arg1)->SetNearClippingPlane(arg2);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45680       };
45681     }
45682   }
45683
45684 }
45685
45686
45687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45688   float jresult ;
45689   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45690   float result;
45691
45692   arg1 = (Dali::CameraActor *)jarg1;
45693   {
45694     try {
45695       result = (float)(arg1)->GetNearClippingPlane();
45696     } catch (std::out_of_range& e) {
45697       {
45698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45699       };
45700     } catch (std::exception& e) {
45701       {
45702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45703       };
45704     } catch (Dali::DaliException e) {
45705       {
45706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45707       };
45708     } catch (...) {
45709       {
45710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45711       };
45712     }
45713   }
45714
45715   jresult = result;
45716   return jresult;
45717 }
45718
45719
45720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45721   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45722   float arg2 ;
45723
45724   arg1 = (Dali::CameraActor *)jarg1;
45725   arg2 = (float)jarg2;
45726   {
45727     try {
45728       (arg1)->SetFarClippingPlane(arg2);
45729     } catch (std::out_of_range& e) {
45730       {
45731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45732       };
45733     } catch (std::exception& e) {
45734       {
45735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45736       };
45737     } catch (Dali::DaliException e) {
45738       {
45739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45740       };
45741     } catch (...) {
45742       {
45743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45744       };
45745     }
45746   }
45747
45748 }
45749
45750
45751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45752   float jresult ;
45753   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45754   float result;
45755
45756   arg1 = (Dali::CameraActor *)jarg1;
45757   {
45758     try {
45759       result = (float)(arg1)->GetFarClippingPlane();
45760     } catch (std::out_of_range& e) {
45761       {
45762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45763       };
45764     } catch (std::exception& e) {
45765       {
45766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (Dali::DaliException e) {
45769       {
45770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45771       };
45772     } catch (...) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45775       };
45776     }
45777   }
45778
45779   jresult = result;
45780   return jresult;
45781 }
45782
45783
45784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45785   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45786   Dali::Vector3 *arg2 = 0 ;
45787
45788   arg1 = (Dali::CameraActor *)jarg1;
45789   arg2 = (Dali::Vector3 *)jarg2;
45790   if (!arg2) {
45791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45792     return ;
45793   }
45794   {
45795     try {
45796       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45797     } catch (std::out_of_range& e) {
45798       {
45799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45800       };
45801     } catch (std::exception& e) {
45802       {
45803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45804       };
45805     } catch (Dali::DaliException e) {
45806       {
45807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45808       };
45809     } catch (...) {
45810       {
45811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45812       };
45813     }
45814   }
45815
45816 }
45817
45818
45819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45820   void * jresult ;
45821   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45822   Dali::Vector3 result;
45823
45824   arg1 = (Dali::CameraActor *)jarg1;
45825   {
45826     try {
45827       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45828     } catch (std::out_of_range& e) {
45829       {
45830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45831       };
45832     } catch (std::exception& e) {
45833       {
45834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45835       };
45836     } catch (Dali::DaliException e) {
45837       {
45838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45839       };
45840     } catch (...) {
45841       {
45842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45843       };
45844     }
45845   }
45846
45847   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45848   return jresult;
45849 }
45850
45851
45852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45853   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45854   bool arg2 ;
45855
45856   arg1 = (Dali::CameraActor *)jarg1;
45857   arg2 = jarg2 ? true : false;
45858   {
45859     try {
45860       (arg1)->SetInvertYAxis(arg2);
45861     } catch (std::out_of_range& e) {
45862       {
45863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45864       };
45865     } catch (std::exception& e) {
45866       {
45867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45868       };
45869     } catch (Dali::DaliException e) {
45870       {
45871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45872       };
45873     } catch (...) {
45874       {
45875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45876       };
45877     }
45878   }
45879
45880 }
45881
45882
45883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45884   unsigned int jresult ;
45885   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45886   bool result;
45887
45888   arg1 = (Dali::CameraActor *)jarg1;
45889   {
45890     try {
45891       result = (bool)(arg1)->GetInvertYAxis();
45892     } catch (std::out_of_range& e) {
45893       {
45894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45895       };
45896     } catch (std::exception& e) {
45897       {
45898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45899       };
45900     } catch (Dali::DaliException e) {
45901       {
45902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45907       };
45908     }
45909   }
45910
45911   jresult = result;
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45917   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45918   Dali::Size *arg2 = 0 ;
45919
45920   arg1 = (Dali::CameraActor *)jarg1;
45921   arg2 = (Dali::Size *)jarg2;
45922   if (!arg2) {
45923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45924     return ;
45925   }
45926   {
45927     try {
45928       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45929     } catch (std::out_of_range& e) {
45930       {
45931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45932       };
45933     } catch (std::exception& e) {
45934       {
45935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45936       };
45937     } catch (Dali::DaliException e) {
45938       {
45939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45940       };
45941     } catch (...) {
45942       {
45943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45944       };
45945     }
45946   }
45947
45948 }
45949
45950
45951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45952   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45953   Dali::Size *arg2 = 0 ;
45954
45955   arg1 = (Dali::CameraActor *)jarg1;
45956   arg2 = (Dali::Size *)jarg2;
45957   if (!arg2) {
45958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45959     return ;
45960   }
45961   {
45962     try {
45963       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45964     } catch (std::out_of_range& e) {
45965       {
45966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45967       };
45968     } catch (std::exception& e) {
45969       {
45970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45971       };
45972     } catch (Dali::DaliException e) {
45973       {
45974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45975       };
45976     } catch (...) {
45977       {
45978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45979       };
45980     }
45981   }
45982
45983 }
45984
45985
45986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45987   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45988   float arg2 ;
45989   float arg3 ;
45990   float arg4 ;
45991   float arg5 ;
45992   float arg6 ;
45993   float arg7 ;
45994
45995   arg1 = (Dali::CameraActor *)jarg1;
45996   arg2 = (float)jarg2;
45997   arg3 = (float)jarg3;
45998   arg4 = (float)jarg4;
45999   arg5 = (float)jarg5;
46000   arg6 = (float)jarg6;
46001   arg7 = (float)jarg7;
46002   {
46003     try {
46004       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
46005     } catch (std::out_of_range& e) {
46006       {
46007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46008       };
46009     } catch (std::exception& e) {
46010       {
46011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46012       };
46013     } catch (Dali::DaliException e) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46016       };
46017     } catch (...) {
46018       {
46019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46020       };
46021     }
46022   }
46023
46024 }
46025
46026
46027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
46028   void * jresult ;
46029   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46030
46031   {
46032     try {
46033       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
46034     } catch (std::out_of_range& e) {
46035       {
46036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46037       };
46038     } catch (std::exception& e) {
46039       {
46040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46041       };
46042     } catch (Dali::DaliException e) {
46043       {
46044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46045       };
46046     } catch (...) {
46047       {
46048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46049       };
46050     }
46051   }
46052
46053   jresult = (void *)result;
46054   return jresult;
46055 }
46056
46057
46058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
46059   void * jresult ;
46060   std::string arg1 ;
46061   Dali::Property::Value arg2 ;
46062   Dali::Property::Value *argp2 ;
46063   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46064
46065   if (!jarg1) {
46066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46067     return 0;
46068   }
46069   (&arg1)->assign(jarg1);
46070   argp2 = (Dali::Property::Value *)jarg2;
46071   if (!argp2) {
46072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
46073     return 0;
46074   }
46075   arg2 = *argp2;
46076   {
46077     try {
46078       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
46079     } catch (std::out_of_range& e) {
46080       {
46081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46082       };
46083     } catch (std::exception& e) {
46084       {
46085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46086       };
46087     } catch (Dali::DaliException e) {
46088       {
46089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46090       };
46091     } catch (...) {
46092       {
46093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46094       };
46095     }
46096   }
46097
46098   jresult = (void *)result;
46099   return jresult;
46100 }
46101
46102
46103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
46104   void * jresult ;
46105   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
46106   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46107
46108   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46109   if (!arg1) {
46110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
46111     return 0;
46112   }
46113   {
46114     try {
46115       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);
46116     } catch (std::out_of_range& e) {
46117       {
46118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46119       };
46120     } catch (std::exception& e) {
46121       {
46122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46123       };
46124     } catch (Dali::DaliException e) {
46125       {
46126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46127       };
46128     } catch (...) {
46129       {
46130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46131       };
46132     }
46133   }
46134
46135   jresult = (void *)result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
46141   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46142   std::string *arg2 = 0 ;
46143
46144   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46145   if (!jarg2) {
46146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46147     return ;
46148   }
46149   std::string arg2_str(jarg2);
46150   arg2 = &arg2_str;
46151   if (arg1) (arg1)->first = *arg2;
46152
46153   //argout typemap for const std::string&
46154
46155 }
46156
46157
46158 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
46159   char * jresult ;
46160   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46161   std::string *result = 0 ;
46162
46163   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46164   result = (std::string *) & ((arg1)->first);
46165   jresult = SWIG_csharp_string_callback(result->c_str());
46166   return jresult;
46167 }
46168
46169
46170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
46171   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46172   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
46173
46174   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46175   arg2 = (Dali::Property::Value *)jarg2;
46176   if (arg1) (arg1)->second = *arg2;
46177 }
46178
46179
46180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46181   void * jresult ;
46182   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46183   Dali::Property::Value *result = 0 ;
46184
46185   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46186   result = (Dali::Property::Value *)& ((arg1)->second);
46187   jresult = (void *)result;
46188   return jresult;
46189 }
46190
46191
46192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46193   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46194
46195   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46196   {
46197     try {
46198       delete arg1;
46199     } catch (std::out_of_range& e) {
46200       {
46201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46202       };
46203     } catch (std::exception& e) {
46204       {
46205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46206       };
46207     } catch (Dali::DaliException e) {
46208       {
46209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46210       };
46211     } catch (...) {
46212       {
46213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46214       };
46215     }
46216   }
46217
46218 }
46219
46220
46221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46222   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46223
46224   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46225   {
46226     try {
46227       (arg1)->clear();
46228     } catch (std::out_of_range& e) {
46229       {
46230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46231       };
46232     } catch (std::exception& e) {
46233       {
46234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46235       };
46236     } catch (Dali::DaliException e) {
46237       {
46238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46239       };
46240     } catch (...) {
46241       {
46242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46243       };
46244     }
46245   }
46246
46247 }
46248
46249
46250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46251   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46252   Dali::TouchPoint *arg2 = 0 ;
46253
46254   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46255   arg2 = (Dali::TouchPoint *)jarg2;
46256   if (!arg2) {
46257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46258     return ;
46259   }
46260   {
46261     try {
46262       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46263     } catch (std::out_of_range& e) {
46264       {
46265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46266       };
46267     } catch (std::exception& e) {
46268       {
46269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46270       };
46271     } catch (Dali::DaliException e) {
46272       {
46273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46274       };
46275     } catch (...) {
46276       {
46277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46278       };
46279     }
46280   }
46281
46282 }
46283
46284
46285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46286   unsigned long jresult ;
46287   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46288   std::vector< Dali::TouchPoint >::size_type result;
46289
46290   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46291   {
46292     try {
46293       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46294     } catch (std::out_of_range& e) {
46295       {
46296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46297       };
46298     } catch (std::exception& e) {
46299       {
46300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46301       };
46302     } catch (Dali::DaliException e) {
46303       {
46304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46305       };
46306     } catch (...) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46309       };
46310     }
46311   }
46312
46313   jresult = (unsigned long)result;
46314   return jresult;
46315 }
46316
46317
46318 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46319   unsigned long jresult ;
46320   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46321   std::vector< Dali::TouchPoint >::size_type result;
46322
46323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46324   {
46325     try {
46326       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46327     } catch (std::out_of_range& e) {
46328       {
46329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46330       };
46331     } catch (std::exception& e) {
46332       {
46333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46334       };
46335     } catch (Dali::DaliException e) {
46336       {
46337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46338       };
46339     } catch (...) {
46340       {
46341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46342       };
46343     }
46344   }
46345
46346   jresult = (unsigned long)result;
46347   return jresult;
46348 }
46349
46350
46351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46352   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46353   std::vector< Dali::TouchPoint >::size_type arg2 ;
46354
46355   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46356   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46357   {
46358     try {
46359       (arg1)->reserve(arg2);
46360     } catch (std::out_of_range& e) {
46361       {
46362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46363       };
46364     } catch (std::exception& e) {
46365       {
46366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46367       };
46368     } catch (Dali::DaliException e) {
46369       {
46370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46371       };
46372     } catch (...) {
46373       {
46374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46375       };
46376     }
46377   }
46378
46379 }
46380
46381
46382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46383   void * jresult ;
46384   std::vector< Dali::TouchPoint > *result = 0 ;
46385
46386   {
46387     try {
46388       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46389     } catch (std::out_of_range& e) {
46390       {
46391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46392       };
46393     } catch (std::exception& e) {
46394       {
46395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46396       };
46397     } catch (Dali::DaliException e) {
46398       {
46399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46400       };
46401     } catch (...) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46404       };
46405     }
46406   }
46407
46408   jresult = (void *)result;
46409   return jresult;
46410 }
46411
46412
46413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46414   void * jresult ;
46415   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46416   std::vector< Dali::TouchPoint > *result = 0 ;
46417
46418   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46419   if (!arg1) {
46420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46421     return 0;
46422   }
46423   {
46424     try {
46425       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46426     } catch (std::out_of_range& e) {
46427       {
46428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46429       };
46430     } catch (std::exception& e) {
46431       {
46432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46433       };
46434     } catch (Dali::DaliException e) {
46435       {
46436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46437       };
46438     } catch (...) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46441       };
46442     }
46443   }
46444
46445   jresult = (void *)result;
46446   return jresult;
46447 }
46448
46449
46450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46451   void * jresult ;
46452   int arg1 ;
46453   std::vector< Dali::TouchPoint > *result = 0 ;
46454
46455   arg1 = (int)jarg1;
46456   {
46457     try {
46458       try {
46459         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46460       }
46461       catch(std::out_of_range &_e) {
46462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46463         return 0;
46464       }
46465
46466     } catch (std::out_of_range& e) {
46467       {
46468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46469       };
46470     } catch (std::exception& e) {
46471       {
46472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46473       };
46474     } catch (Dali::DaliException e) {
46475       {
46476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46477       };
46478     } catch (...) {
46479       {
46480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46481       };
46482     }
46483   }
46484
46485   jresult = (void *)result;
46486   return jresult;
46487 }
46488
46489
46490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46491   void * jresult ;
46492   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46493   int arg2 ;
46494   SwigValueWrapper< Dali::TouchPoint > result;
46495
46496   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46497   arg2 = (int)jarg2;
46498   {
46499     try {
46500       try {
46501         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46502       }
46503       catch(std::out_of_range &_e) {
46504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46505         return 0;
46506       }
46507
46508     } catch (std::out_of_range& e) {
46509       {
46510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46511       };
46512     } catch (std::exception& e) {
46513       {
46514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46515       };
46516     } catch (Dali::DaliException e) {
46517       {
46518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46519       };
46520     } catch (...) {
46521       {
46522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46523       };
46524     }
46525   }
46526
46527   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46528   return jresult;
46529 }
46530
46531
46532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46533   void * jresult ;
46534   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46535   int arg2 ;
46536   Dali::TouchPoint *result = 0 ;
46537
46538   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46539   arg2 = (int)jarg2;
46540   {
46541     try {
46542       try {
46543         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46544       }
46545       catch(std::out_of_range &_e) {
46546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46547         return 0;
46548       }
46549
46550     } catch (std::out_of_range& e) {
46551       {
46552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46553       };
46554     } catch (std::exception& e) {
46555       {
46556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46557       };
46558     } catch (Dali::DaliException e) {
46559       {
46560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46561       };
46562     } catch (...) {
46563       {
46564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46565       };
46566     }
46567   }
46568
46569   jresult = (void *)result;
46570   return jresult;
46571 }
46572
46573
46574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46575   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46576   int arg2 ;
46577   Dali::TouchPoint *arg3 = 0 ;
46578
46579   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46580   arg2 = (int)jarg2;
46581   arg3 = (Dali::TouchPoint *)jarg3;
46582   if (!arg3) {
46583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46584     return ;
46585   }
46586   {
46587     try {
46588       try {
46589         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46590       }
46591       catch(std::out_of_range &_e) {
46592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46593         return ;
46594       }
46595
46596     } catch (std::out_of_range& e) {
46597       {
46598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46599       };
46600     } catch (std::exception& e) {
46601       {
46602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46603       };
46604     } catch (Dali::DaliException e) {
46605       {
46606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46607       };
46608     } catch (...) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46611       };
46612     }
46613   }
46614
46615 }
46616
46617
46618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46619   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46620   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46621
46622   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46623   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46624   if (!arg2) {
46625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46626     return ;
46627   }
46628   {
46629     try {
46630       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46631     } catch (std::out_of_range& e) {
46632       {
46633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46634       };
46635     } catch (std::exception& e) {
46636       {
46637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46638       };
46639     } catch (Dali::DaliException e) {
46640       {
46641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46642       };
46643     } catch (...) {
46644       {
46645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46646       };
46647     }
46648   }
46649
46650 }
46651
46652
46653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46654   void * jresult ;
46655   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46656   int arg2 ;
46657   int arg3 ;
46658   std::vector< Dali::TouchPoint > *result = 0 ;
46659
46660   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46661   arg2 = (int)jarg2;
46662   arg3 = (int)jarg3;
46663   {
46664     try {
46665       try {
46666         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46667       }
46668       catch(std::out_of_range &_e) {
46669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46670         return 0;
46671       }
46672       catch(std::invalid_argument &_e) {
46673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46674         return 0;
46675       }
46676
46677     } catch (std::out_of_range& e) {
46678       {
46679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46680       };
46681     } catch (std::exception& e) {
46682       {
46683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46684       };
46685     } catch (Dali::DaliException e) {
46686       {
46687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46688       };
46689     } catch (...) {
46690       {
46691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46692       };
46693     }
46694   }
46695
46696   jresult = (void *)result;
46697   return jresult;
46698 }
46699
46700
46701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46702   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46703   int arg2 ;
46704   Dali::TouchPoint *arg3 = 0 ;
46705
46706   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46707   arg2 = (int)jarg2;
46708   arg3 = (Dali::TouchPoint *)jarg3;
46709   if (!arg3) {
46710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46711     return ;
46712   }
46713   {
46714     try {
46715       try {
46716         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46717       }
46718       catch(std::out_of_range &_e) {
46719         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46720         return ;
46721       }
46722
46723     } catch (std::out_of_range& e) {
46724       {
46725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46726       };
46727     } catch (std::exception& e) {
46728       {
46729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46730       };
46731     } catch (Dali::DaliException e) {
46732       {
46733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46734       };
46735     } catch (...) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46738       };
46739     }
46740   }
46741
46742 }
46743
46744
46745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46746   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46747   int arg2 ;
46748   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46749
46750   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46751   arg2 = (int)jarg2;
46752   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46753   if (!arg3) {
46754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46755     return ;
46756   }
46757   {
46758     try {
46759       try {
46760         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46761       }
46762       catch(std::out_of_range &_e) {
46763         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46764         return ;
46765       }
46766
46767     } catch (std::out_of_range& e) {
46768       {
46769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46770       };
46771     } catch (std::exception& e) {
46772       {
46773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46774       };
46775     } catch (Dali::DaliException e) {
46776       {
46777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46778       };
46779     } catch (...) {
46780       {
46781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46782       };
46783     }
46784   }
46785
46786 }
46787
46788
46789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46790   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46791   int arg2 ;
46792
46793   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46794   arg2 = (int)jarg2;
46795   {
46796     try {
46797       try {
46798         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46799       }
46800       catch(std::out_of_range &_e) {
46801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46802         return ;
46803       }
46804
46805     } catch (std::out_of_range& e) {
46806       {
46807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46808       };
46809     } catch (std::exception& e) {
46810       {
46811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46812       };
46813     } catch (Dali::DaliException e) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46816       };
46817     } catch (...) {
46818       {
46819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46820       };
46821     }
46822   }
46823
46824 }
46825
46826
46827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46828   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46829   int arg2 ;
46830   int arg3 ;
46831
46832   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46833   arg2 = (int)jarg2;
46834   arg3 = (int)jarg3;
46835   {
46836     try {
46837       try {
46838         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46839       }
46840       catch(std::out_of_range &_e) {
46841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46842         return ;
46843       }
46844       catch(std::invalid_argument &_e) {
46845         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46846         return ;
46847       }
46848
46849     } catch (std::out_of_range& e) {
46850       {
46851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46852       };
46853     } catch (std::exception& e) {
46854       {
46855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46856       };
46857     } catch (Dali::DaliException e) {
46858       {
46859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46860       };
46861     } catch (...) {
46862       {
46863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46864       };
46865     }
46866   }
46867
46868 }
46869
46870
46871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46872   void * jresult ;
46873   Dali::TouchPoint *arg1 = 0 ;
46874   int arg2 ;
46875   std::vector< Dali::TouchPoint > *result = 0 ;
46876
46877   arg1 = (Dali::TouchPoint *)jarg1;
46878   if (!arg1) {
46879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46880     return 0;
46881   }
46882   arg2 = (int)jarg2;
46883   {
46884     try {
46885       try {
46886         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46887       }
46888       catch(std::out_of_range &_e) {
46889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46890         return 0;
46891       }
46892
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (Dali::DaliException e) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46904       };
46905     } catch (...) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46908       };
46909     }
46910   }
46911
46912   jresult = (void *)result;
46913   return jresult;
46914 }
46915
46916
46917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46918   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46919
46920   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46921   {
46922     try {
46923       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46924     } catch (std::out_of_range& e) {
46925       {
46926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46927       };
46928     } catch (std::exception& e) {
46929       {
46930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46931       };
46932     } catch (Dali::DaliException e) {
46933       {
46934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46935       };
46936     } catch (...) {
46937       {
46938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46939       };
46940     }
46941   }
46942
46943 }
46944
46945
46946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46947   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46948   int arg2 ;
46949   int arg3 ;
46950
46951   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46952   arg2 = (int)jarg2;
46953   arg3 = (int)jarg3;
46954   {
46955     try {
46956       try {
46957         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46958       }
46959       catch(std::out_of_range &_e) {
46960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46961         return ;
46962       }
46963       catch(std::invalid_argument &_e) {
46964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46965         return ;
46966       }
46967
46968     } catch (std::out_of_range& e) {
46969       {
46970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46971       };
46972     } catch (std::exception& e) {
46973       {
46974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46975       };
46976     } catch (Dali::DaliException e) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46979       };
46980     } catch (...) {
46981       {
46982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46983       };
46984     }
46985   }
46986
46987 }
46988
46989
46990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46991   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46992   int arg2 ;
46993   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46994
46995   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46996   arg2 = (int)jarg2;
46997   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46998   if (!arg3) {
46999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47000     return ;
47001   }
47002   {
47003     try {
47004       try {
47005         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47006       }
47007       catch(std::out_of_range &_e) {
47008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47009         return ;
47010       }
47011
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47019       };
47020     } catch (Dali::DaliException e) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47023       };
47024     } catch (...) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47027       };
47028     }
47029   }
47030
47031 }
47032
47033
47034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
47035   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47036
47037   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47038   {
47039     try {
47040       delete arg1;
47041     } catch (std::out_of_range& e) {
47042       {
47043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47044       };
47045     } catch (std::exception& e) {
47046       {
47047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47048       };
47049     } catch (Dali::DaliException e) {
47050       {
47051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47052       };
47053     } catch (...) {
47054       {
47055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47056       };
47057     }
47058   }
47059
47060 }
47061
47062
47063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
47064   void * jresult ;
47065   Dali::Rect< int > *result = 0 ;
47066
47067   {
47068     try {
47069       result = (Dali::Rect< int > *)new Dali::Rect< int >();
47070     } catch (std::out_of_range& e) {
47071       {
47072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47073       };
47074     } catch (std::exception& e) {
47075       {
47076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47077       };
47078     } catch (Dali::DaliException e) {
47079       {
47080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47081       };
47082     } catch (...) {
47083       {
47084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47085       };
47086     }
47087   }
47088
47089   jresult = (void *)result;
47090   return jresult;
47091 }
47092
47093
47094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
47095   void * jresult ;
47096   int arg1 ;
47097   int arg2 ;
47098   int arg3 ;
47099   int arg4 ;
47100   Dali::Rect< int > *result = 0 ;
47101
47102   arg1 = (int)jarg1;
47103   arg2 = (int)jarg2;
47104   arg3 = (int)jarg3;
47105   arg4 = (int)jarg4;
47106   {
47107     try {
47108       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
47109     } catch (std::out_of_range& e) {
47110       {
47111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (std::exception& e) {
47114       {
47115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47116       };
47117     } catch (Dali::DaliException e) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47120       };
47121     } catch (...) {
47122       {
47123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47124       };
47125     }
47126   }
47127
47128   jresult = (void *)result;
47129   return jresult;
47130 }
47131
47132
47133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
47134   void * jresult ;
47135   Dali::Rect< int > *arg1 = 0 ;
47136   Dali::Rect< int > *result = 0 ;
47137
47138   arg1 = (Dali::Rect< int > *)jarg1;
47139   if (!arg1) {
47140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47141     return 0;
47142   }
47143   {
47144     try {
47145       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
47146     } catch (std::out_of_range& e) {
47147       {
47148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47149       };
47150     } catch (std::exception& e) {
47151       {
47152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47153       };
47154     } catch (Dali::DaliException e) {
47155       {
47156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47157       };
47158     } catch (...) {
47159       {
47160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47161       };
47162     }
47163   }
47164
47165   jresult = (void *)result;
47166   return jresult;
47167 }
47168
47169
47170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
47171   void * jresult ;
47172   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47173   Dali::Rect< int > *arg2 = 0 ;
47174   Dali::Rect< int > *result = 0 ;
47175
47176   arg1 = (Dali::Rect< int > *)jarg1;
47177   arg2 = (Dali::Rect< int > *)jarg2;
47178   if (!arg2) {
47179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47180     return 0;
47181   }
47182   {
47183     try {
47184       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47185     } catch (std::out_of_range& e) {
47186       {
47187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47188       };
47189     } catch (std::exception& e) {
47190       {
47191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47192       };
47193     } catch (Dali::DaliException e) {
47194       {
47195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47196       };
47197     } catch (...) {
47198       {
47199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47200       };
47201     }
47202   }
47203
47204   jresult = (void *)result;
47205   return jresult;
47206 }
47207
47208
47209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47210   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47211   int arg2 ;
47212   int arg3 ;
47213   int arg4 ;
47214   int arg5 ;
47215
47216   arg1 = (Dali::Rect< int > *)jarg1;
47217   arg2 = (int)jarg2;
47218   arg3 = (int)jarg3;
47219   arg4 = (int)jarg4;
47220   arg5 = (int)jarg5;
47221   {
47222     try {
47223       (arg1)->Set(arg2,arg3,arg4,arg5);
47224     } catch (std::out_of_range& e) {
47225       {
47226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47227       };
47228     } catch (std::exception& e) {
47229       {
47230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47231       };
47232     } catch (Dali::DaliException e) {
47233       {
47234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47235       };
47236     } catch (...) {
47237       {
47238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47239       };
47240     }
47241   }
47242
47243 }
47244
47245
47246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47247   unsigned int jresult ;
47248   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47249   bool result;
47250
47251   arg1 = (Dali::Rect< int > *)jarg1;
47252   {
47253     try {
47254       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47255     } catch (std::out_of_range& e) {
47256       {
47257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47258       };
47259     } catch (std::exception& e) {
47260       {
47261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47262       };
47263     } catch (Dali::DaliException e) {
47264       {
47265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47266       };
47267     } catch (...) {
47268       {
47269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47270       };
47271     }
47272   }
47273
47274   jresult = result;
47275   return jresult;
47276 }
47277
47278
47279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47280   int jresult ;
47281   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47282   int result;
47283
47284   arg1 = (Dali::Rect< int > *)jarg1;
47285   {
47286     try {
47287       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47288     } catch (std::out_of_range& e) {
47289       {
47290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47291       };
47292     } catch (std::exception& e) {
47293       {
47294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47295       };
47296     } catch (Dali::DaliException e) {
47297       {
47298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47299       };
47300     } catch (...) {
47301       {
47302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47303       };
47304     }
47305   }
47306
47307   jresult = result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47313   int jresult ;
47314   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47315   int result;
47316
47317   arg1 = (Dali::Rect< int > *)jarg1;
47318   {
47319     try {
47320       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (Dali::DaliException e) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47332       };
47333     } catch (...) {
47334       {
47335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47336       };
47337     }
47338   }
47339
47340   jresult = result;
47341   return jresult;
47342 }
47343
47344
47345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47346   int jresult ;
47347   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47348   int result;
47349
47350   arg1 = (Dali::Rect< int > *)jarg1;
47351   {
47352     try {
47353       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47354     } catch (std::out_of_range& e) {
47355       {
47356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47357       };
47358     } catch (std::exception& e) {
47359       {
47360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47361       };
47362     } catch (Dali::DaliException e) {
47363       {
47364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47365       };
47366     } catch (...) {
47367       {
47368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47369       };
47370     }
47371   }
47372
47373   jresult = result;
47374   return jresult;
47375 }
47376
47377
47378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47379   int jresult ;
47380   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47381   int result;
47382
47383   arg1 = (Dali::Rect< int > *)jarg1;
47384   {
47385     try {
47386       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47387     } catch (std::out_of_range& e) {
47388       {
47389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47390       };
47391     } catch (std::exception& e) {
47392       {
47393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47394       };
47395     } catch (Dali::DaliException e) {
47396       {
47397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47398       };
47399     } catch (...) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47402       };
47403     }
47404   }
47405
47406   jresult = result;
47407   return jresult;
47408 }
47409
47410
47411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47412   int jresult ;
47413   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47414   int result;
47415
47416   arg1 = (Dali::Rect< int > *)jarg1;
47417   {
47418     try {
47419       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47420     } catch (std::out_of_range& e) {
47421       {
47422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47423       };
47424     } catch (std::exception& e) {
47425       {
47426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47427       };
47428     } catch (Dali::DaliException e) {
47429       {
47430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47431       };
47432     } catch (...) {
47433       {
47434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47435       };
47436     }
47437   }
47438
47439   jresult = result;
47440   return jresult;
47441 }
47442
47443
47444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47445   unsigned int jresult ;
47446   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47447   Dali::Rect< int > *arg2 = 0 ;
47448   bool result;
47449
47450   arg1 = (Dali::Rect< int > *)jarg1;
47451   arg2 = (Dali::Rect< int > *)jarg2;
47452   if (!arg2) {
47453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47454     return 0;
47455   }
47456   {
47457     try {
47458       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47459     } catch (std::out_of_range& e) {
47460       {
47461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47462       };
47463     } catch (std::exception& e) {
47464       {
47465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47466       };
47467     } catch (Dali::DaliException e) {
47468       {
47469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47470       };
47471     } catch (...) {
47472       {
47473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47474       };
47475     }
47476   }
47477
47478   jresult = result;
47479   return jresult;
47480 }
47481
47482
47483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47484   unsigned int jresult ;
47485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47486   Dali::Rect< int > *arg2 = 0 ;
47487   bool result;
47488
47489   arg1 = (Dali::Rect< int > *)jarg1;
47490   arg2 = (Dali::Rect< int > *)jarg2;
47491   if (!arg2) {
47492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47493     return 0;
47494   }
47495   {
47496     try {
47497       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47498     } catch (std::out_of_range& e) {
47499       {
47500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47501       };
47502     } catch (std::exception& e) {
47503       {
47504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47505       };
47506     } catch (Dali::DaliException e) {
47507       {
47508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47509       };
47510     } catch (...) {
47511       {
47512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47513       };
47514     }
47515   }
47516
47517   jresult = result;
47518   return jresult;
47519 }
47520
47521
47522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47523   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47524   int arg2 ;
47525
47526   arg1 = (Dali::Rect< int > *)jarg1;
47527   arg2 = (int)jarg2;
47528   if (arg1) (arg1)->x = arg2;
47529 }
47530
47531
47532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47533   int jresult ;
47534   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47535   int result;
47536
47537   arg1 = (Dali::Rect< int > *)jarg1;
47538   result = (int) ((arg1)->x);
47539   jresult = result;
47540   return jresult;
47541 }
47542
47543
47544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47545   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47546   int arg2 ;
47547
47548   arg1 = (Dali::Rect< int > *)jarg1;
47549   arg2 = (int)jarg2;
47550   if (arg1) (arg1)->left = arg2;
47551 }
47552
47553
47554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47555   int jresult ;
47556   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47557   int result;
47558
47559   arg1 = (Dali::Rect< int > *)jarg1;
47560   result = (int) ((arg1)->left);
47561   jresult = result;
47562   return jresult;
47563 }
47564
47565
47566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47567   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47568   int arg2 ;
47569
47570   arg1 = (Dali::Rect< int > *)jarg1;
47571   arg2 = (int)jarg2;
47572   if (arg1) (arg1)->y = arg2;
47573 }
47574
47575
47576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47577   int jresult ;
47578   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47579   int result;
47580
47581   arg1 = (Dali::Rect< int > *)jarg1;
47582   result = (int) ((arg1)->y);
47583   jresult = result;
47584   return jresult;
47585 }
47586
47587
47588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47589   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47590   int arg2 ;
47591
47592   arg1 = (Dali::Rect< int > *)jarg1;
47593   arg2 = (int)jarg2;
47594   if (arg1) (arg1)->right = arg2;
47595 }
47596
47597
47598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47599   int jresult ;
47600   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47601   int result;
47602
47603   arg1 = (Dali::Rect< int > *)jarg1;
47604   result = (int) ((arg1)->right);
47605   jresult = result;
47606   return jresult;
47607 }
47608
47609
47610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47611   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47612   int arg2 ;
47613
47614   arg1 = (Dali::Rect< int > *)jarg1;
47615   arg2 = (int)jarg2;
47616   if (arg1) (arg1)->width = arg2;
47617 }
47618
47619
47620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47621   int jresult ;
47622   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47623   int result;
47624
47625   arg1 = (Dali::Rect< int > *)jarg1;
47626   result = (int) ((arg1)->width);
47627   jresult = result;
47628   return jresult;
47629 }
47630
47631
47632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47633   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47634   int arg2 ;
47635
47636   arg1 = (Dali::Rect< int > *)jarg1;
47637   arg2 = (int)jarg2;
47638   if (arg1) (arg1)->bottom = arg2;
47639 }
47640
47641
47642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47643   int jresult ;
47644   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47645   int result;
47646
47647   arg1 = (Dali::Rect< int > *)jarg1;
47648   result = (int) ((arg1)->bottom);
47649   jresult = result;
47650   return jresult;
47651 }
47652
47653
47654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47655   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47656   int arg2 ;
47657
47658   arg1 = (Dali::Rect< int > *)jarg1;
47659   arg2 = (int)jarg2;
47660   if (arg1) (arg1)->height = arg2;
47661 }
47662
47663
47664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47665   int jresult ;
47666   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47667   int result;
47668
47669   arg1 = (Dali::Rect< int > *)jarg1;
47670   result = (int) ((arg1)->height);
47671   jresult = result;
47672   return jresult;
47673 }
47674
47675
47676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47677   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47678   int arg2 ;
47679
47680   arg1 = (Dali::Rect< int > *)jarg1;
47681   arg2 = (int)jarg2;
47682   if (arg1) (arg1)->top = arg2;
47683 }
47684
47685
47686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47687   int jresult ;
47688   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47689   int result;
47690
47691   arg1 = (Dali::Rect< int > *)jarg1;
47692   result = (int) ((arg1)->top);
47693   jresult = result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47699   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47700
47701   arg1 = (Dali::Rect< int > *)jarg1;
47702   {
47703     try {
47704       delete arg1;
47705     } catch (std::out_of_range& e) {
47706       {
47707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47708       };
47709     } catch (std::exception& e) {
47710       {
47711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47712       };
47713     } catch (Dali::DaliException e) {
47714       {
47715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47716       };
47717     } catch (...) {
47718       {
47719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47720       };
47721     }
47722   }
47723
47724 }
47725
47726
47727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47728   void * jresult ;
47729   Dali::Rect< float > *result = 0 ;
47730
47731   {
47732     try {
47733       result = (Dali::Rect< float > *)new Dali::Rect< float >();
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_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47759   void * jresult ;
47760   float arg1 ;
47761   float arg2 ;
47762   float arg3 ;
47763   float arg4 ;
47764   Dali::Rect< float > *result = 0 ;
47765
47766   arg1 = (float)jarg1;
47767   arg2 = (float)jarg2;
47768   arg3 = (float)jarg4;
47769   arg4 = (float)jarg3;
47770   {
47771     try {
47772       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47773     } catch (std::out_of_range& e) {
47774       {
47775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (std::exception& e) {
47778       {
47779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (Dali::DaliException e) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47784       };
47785     } catch (...) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47788       };
47789     }
47790   }
47791
47792   jresult = (void *)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47798   void * jresult ;
47799   Dali::Rect< float > *arg1 = 0 ;
47800   Dali::Rect< float > *result = 0 ;
47801
47802   arg1 = (Dali::Rect< float > *)jarg1;
47803   if (!arg1) {
47804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47805     return 0;
47806   }
47807   {
47808     try {
47809       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47810     } catch (std::out_of_range& e) {
47811       {
47812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (std::exception& e) {
47815       {
47816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47817       };
47818     } catch (Dali::DaliException e) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47821       };
47822     } catch (...) {
47823       {
47824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47825       };
47826     }
47827   }
47828
47829   jresult = (void *)result;
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47835   void * jresult ;
47836   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47837   Dali::Rect< float > *arg2 = 0 ;
47838   Dali::Rect< float > *result = 0 ;
47839
47840   arg1 = (Dali::Rect< float > *)jarg1;
47841   arg2 = (Dali::Rect< float > *)jarg2;
47842   if (!arg2) {
47843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47844     return 0;
47845   }
47846   {
47847     try {
47848       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47856       };
47857     } catch (Dali::DaliException e) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47860       };
47861     } catch (...) {
47862       {
47863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47864       };
47865     }
47866   }
47867
47868   jresult = (void *)result;
47869   return jresult;
47870 }
47871
47872
47873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47874   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47875   float arg2 ;
47876   float arg3 ;
47877   float arg4 ;
47878   float arg5 ;
47879
47880   arg1 = (Dali::Rect< float > *)jarg1;
47881   arg2 = (float)jarg2;
47882   arg3 = (float)jarg3;
47883   arg4 = (float)jarg5;
47884   arg5 = (float)jarg4;
47885   {
47886     try {
47887       (arg1)->Set(arg2,arg3,arg4,arg5);
47888     } catch (std::out_of_range& e) {
47889       {
47890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47891       };
47892     } catch (std::exception& e) {
47893       {
47894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47895       };
47896     } catch (Dali::DaliException e) {
47897       {
47898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47899       };
47900     } catch (...) {
47901       {
47902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47903       };
47904     }
47905   }
47906
47907 }
47908
47909
47910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47911   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47912   float arg2 ;
47913
47914   arg1 = (Dali::Rect< float > *)jarg1;
47915   arg2 = (float)jarg2;
47916   if (arg1) (arg1)->left = arg2;
47917 }
47918
47919
47920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47921   float jresult ;
47922   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47923   float result;
47924
47925   arg1 = (Dali::Rect< float > *)jarg1;
47926   result = (float) ((arg1)->left);
47927   jresult = result;
47928   return jresult;
47929 }
47930
47931
47932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47933   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47934   float arg2 ;
47935
47936   arg1 = (Dali::Rect< float > *)jarg1;
47937   arg2 = (float)jarg2;
47938   if (arg1) (arg1)->left = arg2;
47939 }
47940
47941
47942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47943   float jresult ;
47944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47945   float result;
47946
47947   arg1 = (Dali::Rect< float > *)jarg1;
47948   result = (float) ((arg1)->left);
47949   jresult = result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47955   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47956   float arg2 ;
47957
47958   arg1 = (Dali::Rect< float > *)jarg1;
47959   arg2 = (float)jarg2;
47960   if (arg1) (arg1)->right = arg2;
47961 }
47962
47963
47964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47965   float jresult ;
47966   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47967   float result;
47968
47969   arg1 = (Dali::Rect< float > *)jarg1;
47970   result = (float) ((arg1)->right);
47971   jresult = result;
47972   return jresult;
47973 }
47974
47975
47976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47977   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47978   float arg2 ;
47979
47980   arg1 = (Dali::Rect< float > *)jarg1;
47981   arg2 = (float)jarg2;
47982   if (arg1) (arg1)->right = arg2;
47983 }
47984
47985
47986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47987   float jresult ;
47988   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47989   float result;
47990
47991   arg1 = (Dali::Rect< float > *)jarg1;
47992   result = (float) ((arg1)->right);
47993   jresult = result;
47994   return jresult;
47995 }
47996
47997
47998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47999   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48000   float arg2 ;
48001
48002   arg1 = (Dali::Rect< float > *)jarg1;
48003   arg2 = (float)jarg2;
48004   if (arg1) (arg1)->bottom = arg2;
48005 }
48006
48007
48008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
48009   float jresult ;
48010   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48011   float result;
48012
48013   arg1 = (Dali::Rect< float > *)jarg1;
48014   result = (float) ((arg1)->bottom);
48015   jresult = result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
48021   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48022   float arg2 ;
48023
48024   arg1 = (Dali::Rect< float > *)jarg1;
48025   arg2 = (float)jarg2;
48026   if (arg1) (arg1)->top = arg2;
48027 }
48028
48029
48030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
48031   float jresult ;
48032   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48033   float result;
48034
48035   arg1 = (Dali::Rect< float > *)jarg1;
48036   result = (float) ((arg1)->top);
48037   jresult = result;
48038   return jresult;
48039 }
48040
48041
48042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
48043   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48044
48045   arg1 = (Dali::Rect< float > *)jarg1;
48046   {
48047     try {
48048       delete arg1;
48049     } catch (std::out_of_range& e) {
48050       {
48051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (std::exception& e) {
48054       {
48055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48056       };
48057     } catch (Dali::DaliException e) {
48058       {
48059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48060       };
48061     } catch (...) {
48062       {
48063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48064       };
48065     }
48066   }
48067
48068 }
48069
48070
48071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
48072   int jresult ;
48073   int result;
48074
48075   result = (int)Dali::Vector< int >::BaseType;
48076   jresult = (int)result;
48077   return jresult;
48078 }
48079
48080
48081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
48082   void * jresult ;
48083   Dali::Vector< int > *result = 0 ;
48084
48085   {
48086     try {
48087       result = (Dali::Vector< int > *)new Dali::Vector< int >();
48088     } catch (std::out_of_range& e) {
48089       {
48090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48091       };
48092     } catch (std::exception& e) {
48093       {
48094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48095       };
48096     } catch (Dali::DaliException e) {
48097       {
48098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48099       };
48100     } catch (...) {
48101       {
48102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48103       };
48104     }
48105   }
48106
48107   jresult = (void *)result;
48108   return jresult;
48109 }
48110
48111
48112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
48113   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48114
48115   arg1 = (Dali::Vector< int > *)jarg1;
48116   {
48117     try {
48118       delete arg1;
48119     } catch (std::out_of_range& e) {
48120       {
48121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (std::exception& e) {
48124       {
48125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (Dali::DaliException e) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48130       };
48131     } catch (...) {
48132       {
48133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48134       };
48135     }
48136   }
48137
48138 }
48139
48140
48141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
48142   void * jresult ;
48143   Dali::Vector< int > *arg1 = 0 ;
48144   Dali::Vector< int > *result = 0 ;
48145
48146   arg1 = (Dali::Vector< int > *)jarg1;
48147   if (!arg1) {
48148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48149     return 0;
48150   }
48151   {
48152     try {
48153       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
48154     } catch (std::out_of_range& e) {
48155       {
48156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48157       };
48158     } catch (std::exception& e) {
48159       {
48160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48161       };
48162     } catch (Dali::DaliException e) {
48163       {
48164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48165       };
48166     } catch (...) {
48167       {
48168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48169       };
48170     }
48171   }
48172
48173   jresult = (void *)result;
48174   return jresult;
48175 }
48176
48177
48178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48179   void * jresult ;
48180   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48181   Dali::Vector< int > *arg2 = 0 ;
48182   Dali::Vector< int > *result = 0 ;
48183
48184   arg1 = (Dali::Vector< int > *)jarg1;
48185   arg2 = (Dali::Vector< int > *)jarg2;
48186   if (!arg2) {
48187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48188     return 0;
48189   }
48190   {
48191     try {
48192       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48193     } catch (std::out_of_range& e) {
48194       {
48195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48196       };
48197     } catch (std::exception& e) {
48198       {
48199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48200       };
48201     } catch (Dali::DaliException e) {
48202       {
48203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48204       };
48205     } catch (...) {
48206       {
48207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48208       };
48209     }
48210   }
48211
48212   jresult = (void *)result;
48213   return jresult;
48214 }
48215
48216
48217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48218   void * jresult ;
48219   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48220   Dali::Vector< int >::Iterator result;
48221
48222   arg1 = (Dali::Vector< int > *)jarg1;
48223   {
48224     try {
48225       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48226     } catch (std::out_of_range& e) {
48227       {
48228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48229       };
48230     } catch (std::exception& e) {
48231       {
48232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48233       };
48234     } catch (Dali::DaliException e) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48237       };
48238     } catch (...) {
48239       {
48240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48241       };
48242     }
48243   }
48244
48245   jresult = (void *)result;
48246   return jresult;
48247 }
48248
48249
48250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48251   void * jresult ;
48252   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48253   Dali::Vector< int >::Iterator result;
48254
48255   arg1 = (Dali::Vector< int > *)jarg1;
48256   {
48257     try {
48258       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48259     } catch (std::out_of_range& e) {
48260       {
48261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48262       };
48263     } catch (std::exception& e) {
48264       {
48265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48266       };
48267     } catch (Dali::DaliException e) {
48268       {
48269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48270       };
48271     } catch (...) {
48272       {
48273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48274       };
48275     }
48276   }
48277
48278   jresult = (void *)result;
48279   return jresult;
48280 }
48281
48282
48283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48284   void * jresult ;
48285   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48286   Dali::Vector< int >::SizeType arg2 ;
48287   Dali::Vector< int >::ItemType *result = 0 ;
48288
48289   arg1 = (Dali::Vector< int > *)jarg1;
48290   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48291   {
48292     try {
48293       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48294     } catch (std::out_of_range& e) {
48295       {
48296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48297       };
48298     } catch (std::exception& e) {
48299       {
48300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48301       };
48302     } catch (Dali::DaliException e) {
48303       {
48304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48305       };
48306     } catch (...) {
48307       {
48308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48309       };
48310     }
48311   }
48312
48313   jresult = (void *)result;
48314   return jresult;
48315 }
48316
48317
48318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48319   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48320   Dali::Vector< int >::ItemType *arg2 = 0 ;
48321   Dali::Vector< int >::ItemType temp2 ;
48322
48323   arg1 = (Dali::Vector< int > *)jarg1;
48324   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48325   arg2 = &temp2;
48326   {
48327     try {
48328       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48329     } catch (std::out_of_range& e) {
48330       {
48331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48332       };
48333     } catch (std::exception& e) {
48334       {
48335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48336       };
48337     } catch (Dali::DaliException e) {
48338       {
48339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48340       };
48341     } catch (...) {
48342       {
48343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48344       };
48345     }
48346   }
48347
48348 }
48349
48350
48351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48352   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48353   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48354   Dali::Vector< int >::ItemType *arg3 = 0 ;
48355   Dali::Vector< int >::ItemType temp3 ;
48356
48357   arg1 = (Dali::Vector< int > *)jarg1;
48358   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48359   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48360   arg3 = &temp3;
48361   {
48362     try {
48363       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48364     } catch (std::out_of_range& e) {
48365       {
48366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48367       };
48368     } catch (std::exception& e) {
48369       {
48370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48371       };
48372     } catch (Dali::DaliException e) {
48373       {
48374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48375       };
48376     } catch (...) {
48377       {
48378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48379       };
48380     }
48381   }
48382
48383 }
48384
48385
48386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48387   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48388   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48389   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48390   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48391
48392   arg1 = (Dali::Vector< int > *)jarg1;
48393   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48394   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48395   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48396   {
48397     try {
48398       (arg1)->Insert(arg2,arg3,arg4);
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48406       };
48407     } catch (Dali::DaliException e) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48410       };
48411     } catch (...) {
48412       {
48413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48414       };
48415     }
48416   }
48417
48418 }
48419
48420
48421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48422   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48423   Dali::Vector< int >::SizeType arg2 ;
48424
48425   arg1 = (Dali::Vector< int > *)jarg1;
48426   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48427   {
48428     try {
48429       (arg1)->Reserve(arg2);
48430     } catch (std::out_of_range& e) {
48431       {
48432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48433       };
48434     } catch (std::exception& e) {
48435       {
48436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48437       };
48438     } catch (Dali::DaliException e) {
48439       {
48440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48441       };
48442     } catch (...) {
48443       {
48444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48445       };
48446     }
48447   }
48448
48449 }
48450
48451
48452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48453   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48454   Dali::Vector< int >::SizeType arg2 ;
48455
48456   arg1 = (Dali::Vector< int > *)jarg1;
48457   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48458   {
48459     try {
48460       (arg1)->Resize(arg2);
48461     } catch (std::out_of_range& e) {
48462       {
48463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48464       };
48465     } catch (std::exception& e) {
48466       {
48467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48468       };
48469     } catch (Dali::DaliException e) {
48470       {
48471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48472       };
48473     } catch (...) {
48474       {
48475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48476       };
48477     }
48478   }
48479
48480 }
48481
48482
48483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48484   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48485   Dali::Vector< int >::SizeType arg2 ;
48486   Dali::Vector< int >::ItemType *arg3 = 0 ;
48487   Dali::Vector< int >::ItemType temp3 ;
48488
48489   arg1 = (Dali::Vector< int > *)jarg1;
48490   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48491   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48492   arg3 = &temp3;
48493   {
48494     try {
48495       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48496     } catch (std::out_of_range& e) {
48497       {
48498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48499       };
48500     } catch (std::exception& e) {
48501       {
48502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48503       };
48504     } catch (Dali::DaliException e) {
48505       {
48506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48507       };
48508     } catch (...) {
48509       {
48510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48511       };
48512     }
48513   }
48514
48515 }
48516
48517
48518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48519   void * jresult ;
48520   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48521   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48522   Dali::Vector< int >::Iterator result;
48523
48524   arg1 = (Dali::Vector< int > *)jarg1;
48525   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48526   {
48527     try {
48528       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48529     } catch (std::out_of_range& e) {
48530       {
48531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48532       };
48533     } catch (std::exception& e) {
48534       {
48535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48536       };
48537     } catch (Dali::DaliException e) {
48538       {
48539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48540       };
48541     } catch (...) {
48542       {
48543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48544       };
48545     }
48546   }
48547
48548   jresult = (void *)result;
48549   return jresult;
48550 }
48551
48552
48553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48554   void * jresult ;
48555   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48556   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48557   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48558   Dali::Vector< int >::Iterator result;
48559
48560   arg1 = (Dali::Vector< int > *)jarg1;
48561   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48562   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48563   {
48564     try {
48565       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48566     } catch (std::out_of_range& e) {
48567       {
48568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48569       };
48570     } catch (std::exception& e) {
48571       {
48572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48573       };
48574     } catch (Dali::DaliException e) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48581       };
48582     }
48583   }
48584
48585   jresult = (void *)result;
48586   return jresult;
48587 }
48588
48589
48590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48591   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48592   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48593
48594   arg1 = (Dali::Vector< int > *)jarg1;
48595   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48596   {
48597     try {
48598       (arg1)->Remove(arg2);
48599     } catch (std::out_of_range& e) {
48600       {
48601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48602       };
48603     } catch (std::exception& e) {
48604       {
48605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (Dali::DaliException e) {
48608       {
48609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617
48618 }
48619
48620
48621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48622   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48623   Dali::Vector< int > *arg2 = 0 ;
48624
48625   arg1 = (Dali::Vector< int > *)jarg1;
48626   arg2 = (Dali::Vector< int > *)jarg2;
48627   if (!arg2) {
48628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48629     return ;
48630   }
48631   {
48632     try {
48633       (arg1)->Swap(*arg2);
48634     } catch (std::out_of_range& e) {
48635       {
48636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48637       };
48638     } catch (std::exception& e) {
48639       {
48640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48641       };
48642     } catch (Dali::DaliException e) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48645       };
48646     } catch (...) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48649       };
48650     }
48651   }
48652
48653 }
48654
48655
48656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48657   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48658
48659   arg1 = (Dali::Vector< int > *)jarg1;
48660   {
48661     try {
48662       (arg1)->Clear();
48663     } catch (std::out_of_range& e) {
48664       {
48665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48666       };
48667     } catch (std::exception& e) {
48668       {
48669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48670       };
48671     } catch (Dali::DaliException e) {
48672       {
48673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48674       };
48675     } catch (...) {
48676       {
48677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48678       };
48679     }
48680   }
48681
48682 }
48683
48684
48685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48686   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48687
48688   arg1 = (Dali::Vector< int > *)jarg1;
48689   {
48690     try {
48691       (arg1)->Release();
48692     } catch (std::out_of_range& e) {
48693       {
48694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48695       };
48696     } catch (std::exception& e) {
48697       {
48698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48699       };
48700     } catch (Dali::DaliException e) {
48701       {
48702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48703       };
48704     } catch (...) {
48705       {
48706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48707       };
48708     }
48709   }
48710
48711 }
48712
48713
48714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48715   int jresult ;
48716   int result;
48717
48718   result = (int)Dali::Vector< float >::BaseType;
48719   jresult = (int)result;
48720   return jresult;
48721 }
48722
48723
48724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48725   void * jresult ;
48726   Dali::Vector< float > *result = 0 ;
48727
48728   {
48729     try {
48730       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48731     } catch (std::out_of_range& e) {
48732       {
48733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48734       };
48735     } catch (std::exception& e) {
48736       {
48737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48738       };
48739     } catch (Dali::DaliException e) {
48740       {
48741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48742       };
48743     } catch (...) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48746       };
48747     }
48748   }
48749
48750   jresult = (void *)result;
48751   return jresult;
48752 }
48753
48754
48755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48756   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48757
48758   arg1 = (Dali::Vector< float > *)jarg1;
48759   {
48760     try {
48761       delete arg1;
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48777       };
48778     }
48779   }
48780
48781 }
48782
48783
48784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48785   void * jresult ;
48786   Dali::Vector< float > *arg1 = 0 ;
48787   Dali::Vector< float > *result = 0 ;
48788
48789   arg1 = (Dali::Vector< float > *)jarg1;
48790   if (!arg1) {
48791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48792     return 0;
48793   }
48794   {
48795     try {
48796       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48797     } catch (std::out_of_range& e) {
48798       {
48799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48800       };
48801     } catch (std::exception& e) {
48802       {
48803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48804       };
48805     } catch (Dali::DaliException e) {
48806       {
48807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48808       };
48809     } catch (...) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48812       };
48813     }
48814   }
48815
48816   jresult = (void *)result;
48817   return jresult;
48818 }
48819
48820
48821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48822   void * jresult ;
48823   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48824   Dali::Vector< float > *arg2 = 0 ;
48825   Dali::Vector< float > *result = 0 ;
48826
48827   arg1 = (Dali::Vector< float > *)jarg1;
48828   arg2 = (Dali::Vector< float > *)jarg2;
48829   if (!arg2) {
48830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48831     return 0;
48832   }
48833   {
48834     try {
48835       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48836     } catch (std::out_of_range& e) {
48837       {
48838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48839       };
48840     } catch (std::exception& e) {
48841       {
48842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48843       };
48844     } catch (Dali::DaliException e) {
48845       {
48846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48847       };
48848     } catch (...) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48851       };
48852     }
48853   }
48854
48855   jresult = (void *)result;
48856   return jresult;
48857 }
48858
48859
48860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48861   void * jresult ;
48862   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48863   Dali::Vector< float >::Iterator result;
48864
48865   arg1 = (Dali::Vector< float > *)jarg1;
48866   {
48867     try {
48868       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48869     } catch (std::out_of_range& e) {
48870       {
48871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48872       };
48873     } catch (std::exception& e) {
48874       {
48875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48876       };
48877     } catch (Dali::DaliException e) {
48878       {
48879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48880       };
48881     } catch (...) {
48882       {
48883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48884       };
48885     }
48886   }
48887
48888   jresult = (void *)result;
48889   return jresult;
48890 }
48891
48892
48893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48894   void * jresult ;
48895   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48896   Dali::Vector< float >::Iterator result;
48897
48898   arg1 = (Dali::Vector< float > *)jarg1;
48899   {
48900     try {
48901       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48902     } catch (std::out_of_range& e) {
48903       {
48904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48905       };
48906     } catch (std::exception& e) {
48907       {
48908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48909       };
48910     } catch (Dali::DaliException e) {
48911       {
48912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48913       };
48914     } catch (...) {
48915       {
48916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48917       };
48918     }
48919   }
48920
48921   jresult = (void *)result;
48922   return jresult;
48923 }
48924
48925
48926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48927   void * jresult ;
48928   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48929   Dali::Vector< float >::SizeType arg2 ;
48930   Dali::Vector< float >::ItemType *result = 0 ;
48931
48932   arg1 = (Dali::Vector< float > *)jarg1;
48933   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48934   {
48935     try {
48936       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48937     } catch (std::out_of_range& e) {
48938       {
48939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48940       };
48941     } catch (std::exception& e) {
48942       {
48943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48944       };
48945     } catch (Dali::DaliException e) {
48946       {
48947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48948       };
48949     } catch (...) {
48950       {
48951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48952       };
48953     }
48954   }
48955
48956   jresult = (void *)result;
48957   return jresult;
48958 }
48959
48960
48961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48962   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48963   Dali::Vector< float >::ItemType *arg2 = 0 ;
48964   Dali::Vector< float >::ItemType temp2 ;
48965
48966   arg1 = (Dali::Vector< float > *)jarg1;
48967   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48968   arg2 = &temp2;
48969   {
48970     try {
48971       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48972     } catch (std::out_of_range& e) {
48973       {
48974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (std::exception& e) {
48977       {
48978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48979       };
48980     } catch (Dali::DaliException e) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48983       };
48984     } catch (...) {
48985       {
48986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48987       };
48988     }
48989   }
48990
48991 }
48992
48993
48994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48995   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48996   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48997   Dali::Vector< float >::ItemType *arg3 = 0 ;
48998   Dali::Vector< float >::ItemType temp3 ;
48999
49000   arg1 = (Dali::Vector< float > *)jarg1;
49001   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49002   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49003   arg3 = &temp3;
49004   {
49005     try {
49006       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49007     } catch (std::out_of_range& e) {
49008       {
49009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49010       };
49011     } catch (std::exception& e) {
49012       {
49013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49014       };
49015     } catch (Dali::DaliException e) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49022       };
49023     }
49024   }
49025
49026 }
49027
49028
49029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49030   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49031   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49032   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49033   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
49034
49035   arg1 = (Dali::Vector< float > *)jarg1;
49036   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49037   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49038   arg4 = (Dali::Vector< float >::Iterator)jarg4;
49039   {
49040     try {
49041       (arg1)->Insert(arg2,arg3,arg4);
49042     } catch (std::out_of_range& e) {
49043       {
49044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (std::exception& e) {
49047       {
49048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49049       };
49050     } catch (Dali::DaliException e) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49053       };
49054     } catch (...) {
49055       {
49056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49057       };
49058     }
49059   }
49060
49061 }
49062
49063
49064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
49065   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49066   Dali::Vector< float >::SizeType arg2 ;
49067
49068   arg1 = (Dali::Vector< float > *)jarg1;
49069   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49070   {
49071     try {
49072       (arg1)->Reserve(arg2);
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49080       };
49081     } catch (Dali::DaliException e) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49088       };
49089     }
49090   }
49091
49092 }
49093
49094 //// ========================= end of part 2 =============================
49095
49096 //// ========================== start part 3 ===============================
49097
49098
49099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49100   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49101   Dali::Vector< float >::SizeType arg2 ;
49102
49103   arg1 = (Dali::Vector< float > *)jarg1;
49104   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49105   {
49106     try {
49107       (arg1)->Resize(arg2);
49108     } catch (std::out_of_range& e) {
49109       {
49110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49111       };
49112     } catch (std::exception& e) {
49113       {
49114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49115       };
49116     } catch (Dali::DaliException e) {
49117       {
49118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49119       };
49120     } catch (...) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49123       };
49124     }
49125   }
49126
49127 }
49128
49129
49130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
49131   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49132   Dali::Vector< float >::SizeType arg2 ;
49133   Dali::Vector< float >::ItemType *arg3 = 0 ;
49134   Dali::Vector< float >::ItemType temp3 ;
49135
49136   arg1 = (Dali::Vector< float > *)jarg1;
49137   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49138   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49139   arg3 = &temp3;
49140   {
49141     try {
49142       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49143     } catch (std::out_of_range& e) {
49144       {
49145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49146       };
49147     } catch (std::exception& e) {
49148       {
49149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49150       };
49151     } catch (Dali::DaliException e) {
49152       {
49153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49154       };
49155     } catch (...) {
49156       {
49157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49158       };
49159     }
49160   }
49161
49162 }
49163
49164
49165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
49166   void * jresult ;
49167   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49168   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49169   Dali::Vector< float >::Iterator result;
49170
49171   arg1 = (Dali::Vector< float > *)jarg1;
49172   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49173   {
49174     try {
49175       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
49176     } catch (std::out_of_range& e) {
49177       {
49178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49179       };
49180     } catch (std::exception& e) {
49181       {
49182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49183       };
49184     } catch (Dali::DaliException e) {
49185       {
49186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49187       };
49188     } catch (...) {
49189       {
49190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49191       };
49192     }
49193   }
49194
49195   jresult = (void *)result;
49196   return jresult;
49197 }
49198
49199
49200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49201   void * jresult ;
49202   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49203   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49204   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49205   Dali::Vector< float >::Iterator result;
49206
49207   arg1 = (Dali::Vector< float > *)jarg1;
49208   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49209   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49210   {
49211     try {
49212       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49213     } catch (std::out_of_range& e) {
49214       {
49215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49216       };
49217     } catch (std::exception& e) {
49218       {
49219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49220       };
49221     } catch (Dali::DaliException e) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49224       };
49225     } catch (...) {
49226       {
49227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49228       };
49229     }
49230   }
49231
49232   jresult = (void *)result;
49233   return jresult;
49234 }
49235
49236
49237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49238   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49239   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49240
49241   arg1 = (Dali::Vector< float > *)jarg1;
49242   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49243   {
49244     try {
49245       (arg1)->Remove(arg2);
49246     } catch (std::out_of_range& e) {
49247       {
49248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49249       };
49250     } catch (std::exception& e) {
49251       {
49252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49253       };
49254     } catch (Dali::DaliException e) {
49255       {
49256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49257       };
49258     } catch (...) {
49259       {
49260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49261       };
49262     }
49263   }
49264
49265 }
49266
49267
49268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49269   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49270   Dali::Vector< float > *arg2 = 0 ;
49271
49272   arg1 = (Dali::Vector< float > *)jarg1;
49273   arg2 = (Dali::Vector< float > *)jarg2;
49274   if (!arg2) {
49275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49276     return ;
49277   }
49278   {
49279     try {
49280       (arg1)->Swap(*arg2);
49281     } catch (std::out_of_range& e) {
49282       {
49283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49284       };
49285     } catch (std::exception& e) {
49286       {
49287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49288       };
49289     } catch (Dali::DaliException e) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49292       };
49293     } catch (...) {
49294       {
49295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49296       };
49297     }
49298   }
49299
49300 }
49301
49302
49303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49304   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49305
49306   arg1 = (Dali::Vector< float > *)jarg1;
49307   {
49308     try {
49309       (arg1)->Clear();
49310     } catch (std::out_of_range& e) {
49311       {
49312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (std::exception& e) {
49315       {
49316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49317       };
49318     } catch (Dali::DaliException e) {
49319       {
49320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49321       };
49322     } catch (...) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49325       };
49326     }
49327   }
49328
49329 }
49330
49331
49332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49333   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49334
49335   arg1 = (Dali::Vector< float > *)jarg1;
49336   {
49337     try {
49338       (arg1)->Release();
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49346       };
49347     } catch (Dali::DaliException e) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49354       };
49355     }
49356   }
49357
49358 }
49359
49360
49361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49362   int jresult ;
49363   int result;
49364
49365   result = (int)Dali::Vector< unsigned char >::BaseType;
49366   jresult = (int)result;
49367   return jresult;
49368 }
49369
49370
49371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49372   void * jresult ;
49373   Dali::Vector< unsigned char > *result = 0 ;
49374
49375   {
49376     try {
49377       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49378     } catch (std::out_of_range& e) {
49379       {
49380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49381       };
49382     } catch (std::exception& e) {
49383       {
49384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49385       };
49386     } catch (Dali::DaliException e) {
49387       {
49388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49389       };
49390     } catch (...) {
49391       {
49392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49393       };
49394     }
49395   }
49396
49397   jresult = (void *)result;
49398   return jresult;
49399 }
49400
49401
49402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49403   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49404
49405   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49406   {
49407     try {
49408       delete arg1;
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49416       };
49417     } catch (Dali::DaliException e) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49424       };
49425     }
49426   }
49427
49428 }
49429
49430
49431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49432   void * jresult ;
49433   Dali::Vector< unsigned char > *arg1 = 0 ;
49434   Dali::Vector< unsigned char > *result = 0 ;
49435
49436   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49437   if (!arg1) {
49438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49439     return 0;
49440   }
49441   {
49442     try {
49443       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49444     } catch (std::out_of_range& e) {
49445       {
49446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49447       };
49448     } catch (std::exception& e) {
49449       {
49450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49451       };
49452     } catch (Dali::DaliException e) {
49453       {
49454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49455       };
49456     } catch (...) {
49457       {
49458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49459       };
49460     }
49461   }
49462
49463   jresult = (void *)result;
49464   return jresult;
49465 }
49466
49467
49468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49469   void * jresult ;
49470   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49471   Dali::Vector< unsigned char > *arg2 = 0 ;
49472   Dali::Vector< unsigned char > *result = 0 ;
49473
49474   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49475   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49476   if (!arg2) {
49477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49478     return 0;
49479   }
49480   {
49481     try {
49482       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49483     } catch (std::out_of_range& e) {
49484       {
49485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49486       };
49487     } catch (std::exception& e) {
49488       {
49489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49490       };
49491     } catch (Dali::DaliException e) {
49492       {
49493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49494       };
49495     } catch (...) {
49496       {
49497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49498       };
49499     }
49500   }
49501
49502   jresult = (void *)result;
49503   return jresult;
49504 }
49505
49506
49507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49508   void * jresult ;
49509   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49510   Dali::Vector< unsigned char >::Iterator result;
49511
49512   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49513   {
49514     try {
49515       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49516     } catch (std::out_of_range& e) {
49517       {
49518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49519       };
49520     } catch (std::exception& e) {
49521       {
49522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49523       };
49524     } catch (Dali::DaliException e) {
49525       {
49526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49527       };
49528     } catch (...) {
49529       {
49530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49531       };
49532     }
49533   }
49534
49535   jresult = (void *)result;
49536   return jresult;
49537 }
49538
49539
49540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49541   void * jresult ;
49542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49543   Dali::Vector< unsigned char >::Iterator result;
49544
49545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49546   {
49547     try {
49548       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49549     } catch (std::out_of_range& e) {
49550       {
49551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49552       };
49553     } catch (std::exception& e) {
49554       {
49555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49556       };
49557     } catch (Dali::DaliException e) {
49558       {
49559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49560       };
49561     } catch (...) {
49562       {
49563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49564       };
49565     }
49566   }
49567
49568   jresult = (void *)result;
49569   return jresult;
49570 }
49571
49572
49573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49574   void * jresult ;
49575   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49576   Dali::Vector< unsigned char >::SizeType arg2 ;
49577   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49578
49579   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49580   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49581   {
49582     try {
49583       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49584     } catch (std::out_of_range& e) {
49585       {
49586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49587       };
49588     } catch (std::exception& e) {
49589       {
49590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49591       };
49592     } catch (Dali::DaliException e) {
49593       {
49594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49595       };
49596     } catch (...) {
49597       {
49598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49599       };
49600     }
49601   }
49602
49603   jresult = (void *)result;
49604   return jresult;
49605 }
49606
49607
49608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49609   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49610   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49611   Dali::Vector< unsigned char >::ItemType temp2 ;
49612
49613   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49614   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49615   arg2 = &temp2;
49616   {
49617     try {
49618       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49626       };
49627     } catch (Dali::DaliException e) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49634       };
49635     }
49636   }
49637
49638 }
49639
49640
49641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49642   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49643   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49644   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49645   Dali::Vector< unsigned char >::ItemType temp3 ;
49646
49647   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49648   arg2 = jarg2;
49649   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49650   arg3 = &temp3;
49651   {
49652     try {
49653       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49654     } catch (std::out_of_range& e) {
49655       {
49656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49657       };
49658     } catch (std::exception& e) {
49659       {
49660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49661       };
49662     } catch (Dali::DaliException e) {
49663       {
49664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49665       };
49666     } catch (...) {
49667       {
49668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49669       };
49670     }
49671   }
49672
49673
49674
49675 }
49676
49677
49678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49679   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49680   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49681   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49682   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49683
49684   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49685   arg2 = jarg2;
49686   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49687   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49688   {
49689     try {
49690       (arg1)->Insert(arg2,arg3,arg4);
49691     } catch (std::out_of_range& e) {
49692       {
49693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49694       };
49695     } catch (std::exception& e) {
49696       {
49697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49698       };
49699     } catch (Dali::DaliException e) {
49700       {
49701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49702       };
49703     } catch (...) {
49704       {
49705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49706       };
49707     }
49708   }
49709
49710
49711
49712 }
49713
49714
49715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49716   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49717   Dali::Vector< unsigned char >::SizeType arg2 ;
49718
49719   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49720   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49721   {
49722     try {
49723       (arg1)->Reserve(arg2);
49724     } catch (std::out_of_range& e) {
49725       {
49726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49727       };
49728     } catch (std::exception& e) {
49729       {
49730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49731       };
49732     } catch (Dali::DaliException e) {
49733       {
49734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49735       };
49736     } catch (...) {
49737       {
49738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49739       };
49740     }
49741   }
49742
49743 }
49744
49745
49746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49747   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49748   Dali::Vector< unsigned char >::SizeType arg2 ;
49749
49750   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49751   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49752   {
49753     try {
49754       (arg1)->Resize(arg2);
49755     } catch (std::out_of_range& e) {
49756       {
49757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (std::exception& e) {
49760       {
49761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (Dali::DaliException e) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773
49774 }
49775
49776
49777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49778   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49779   Dali::Vector< unsigned char >::SizeType arg2 ;
49780   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49781   Dali::Vector< unsigned char >::ItemType temp3 ;
49782
49783   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49784   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49785   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49786   arg3 = &temp3;
49787   {
49788     try {
49789       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49790     } catch (std::out_of_range& e) {
49791       {
49792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49793       };
49794     } catch (std::exception& e) {
49795       {
49796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49797       };
49798     } catch (Dali::DaliException e) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49801       };
49802     } catch (...) {
49803       {
49804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49805       };
49806     }
49807   }
49808
49809 }
49810
49811
49812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49813   void * jresult ;
49814   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49815   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49816   Dali::Vector< unsigned char >::Iterator result;
49817
49818   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49819   arg2 = jarg2;
49820   {
49821     try {
49822       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49823     } catch (std::out_of_range& e) {
49824       {
49825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49826       };
49827     } catch (std::exception& e) {
49828       {
49829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49830       };
49831     } catch (Dali::DaliException e) {
49832       {
49833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49834       };
49835     } catch (...) {
49836       {
49837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49838       };
49839     }
49840   }
49841
49842   jresult = (void *)result;
49843
49844
49845   return jresult;
49846 }
49847
49848
49849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49850   void * jresult ;
49851   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49852   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49853   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49854   Dali::Vector< unsigned char >::Iterator result;
49855
49856   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49857   arg2 = jarg2;
49858   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49859   {
49860     try {
49861       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49862     } catch (std::out_of_range& e) {
49863       {
49864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49865       };
49866     } catch (std::exception& e) {
49867       {
49868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49869       };
49870     } catch (Dali::DaliException e) {
49871       {
49872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49873       };
49874     } catch (...) {
49875       {
49876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49877       };
49878     }
49879   }
49880
49881   jresult = (void *)result;
49882
49883
49884   return jresult;
49885 }
49886
49887
49888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49889   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49890   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49891
49892   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49893   arg2 = jarg2;
49894   {
49895     try {
49896       (arg1)->Remove(arg2);
49897     } catch (std::out_of_range& e) {
49898       {
49899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49900       };
49901     } catch (std::exception& e) {
49902       {
49903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49904       };
49905     } catch (Dali::DaliException e) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49908       };
49909     } catch (...) {
49910       {
49911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49912       };
49913     }
49914   }
49915
49916
49917
49918 }
49919
49920
49921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49922   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49923   Dali::Vector< unsigned char > *arg2 = 0 ;
49924
49925   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49926   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49927   if (!arg2) {
49928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49929     return ;
49930   }
49931   {
49932     try {
49933       (arg1)->Swap(*arg2);
49934     } catch (std::out_of_range& e) {
49935       {
49936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49937       };
49938     } catch (std::exception& e) {
49939       {
49940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49941       };
49942     } catch (Dali::DaliException e) {
49943       {
49944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49945       };
49946     } catch (...) {
49947       {
49948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49949       };
49950     }
49951   }
49952
49953 }
49954
49955
49956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49957   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49958
49959   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49960   {
49961     try {
49962       (arg1)->Clear();
49963     } catch (std::out_of_range& e) {
49964       {
49965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (std::exception& e) {
49968       {
49969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (Dali::DaliException e) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49978       };
49979     }
49980   }
49981
49982 }
49983
49984
49985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49986   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49987
49988   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49989   {
49990     try {
49991       (arg1)->Release();
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 int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
50015   int jresult ;
50016   int result;
50017
50018   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
50019   jresult = (int)result;
50020   return jresult;
50021 }
50022
50023
50024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
50025   void * jresult ;
50026   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50027
50028   {
50029     try {
50030       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
50031     } catch (std::out_of_range& e) {
50032       {
50033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50034       };
50035     } catch (std::exception& e) {
50036       {
50037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50038       };
50039     } catch (Dali::DaliException e) {
50040       {
50041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50042       };
50043     } catch (...) {
50044       {
50045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50046       };
50047     }
50048   }
50049
50050   jresult = (void *)result;
50051   return jresult;
50052 }
50053
50054
50055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
50056   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50057
50058   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50059   {
50060     try {
50061       delete arg1;
50062     } catch (std::out_of_range& e) {
50063       {
50064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50065       };
50066     } catch (std::exception& e) {
50067       {
50068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (Dali::DaliException e) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50077       };
50078     }
50079   }
50080
50081 }
50082
50083
50084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
50085   void * jresult ;
50086   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
50087   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50088
50089   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50090   if (!arg1) {
50091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50092     return 0;
50093   }
50094   {
50095     try {
50096       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
50097     } catch (std::out_of_range& e) {
50098       {
50099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50100       };
50101     } catch (std::exception& e) {
50102       {
50103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50104       };
50105     } catch (Dali::DaliException e) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50108       };
50109     } catch (...) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50112       };
50113     }
50114   }
50115
50116   jresult = (void *)result;
50117   return jresult;
50118 }
50119
50120
50121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
50122   void * jresult ;
50123   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50124   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50125   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50126
50127   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50128   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50129   if (!arg2) {
50130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50131     return 0;
50132   }
50133   {
50134     try {
50135       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
50136     } catch (std::out_of_range& e) {
50137       {
50138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (std::exception& e) {
50141       {
50142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (Dali::DaliException e) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50147       };
50148     } catch (...) {
50149       {
50150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50151       };
50152     }
50153   }
50154
50155   jresult = (void *)result;
50156   return jresult;
50157 }
50158
50159
50160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
50161   void * jresult ;
50162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50163   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50164
50165   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50166   {
50167     try {
50168       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
50169     } catch (std::out_of_range& e) {
50170       {
50171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50172       };
50173     } catch (std::exception& e) {
50174       {
50175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50176       };
50177     } catch (Dali::DaliException e) {
50178       {
50179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50180       };
50181     } catch (...) {
50182       {
50183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50184       };
50185     }
50186   }
50187
50188   jresult = (void *)result;
50189   return jresult;
50190 }
50191
50192
50193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50194   void * jresult ;
50195   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50196   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50197
50198   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50199   {
50200     try {
50201       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50202     } catch (std::out_of_range& e) {
50203       {
50204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50205       };
50206     } catch (std::exception& e) {
50207       {
50208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (Dali::DaliException e) {
50211       {
50212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50213       };
50214     } catch (...) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50217       };
50218     }
50219   }
50220
50221   jresult = (void *)result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50227   void * jresult ;
50228   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50229   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50230   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50231
50232   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50233   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50234   {
50235     try {
50236       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50237     } catch (std::out_of_range& e) {
50238       {
50239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50240       };
50241     } catch (std::exception& e) {
50242       {
50243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50244       };
50245     } catch (Dali::DaliException e) {
50246       {
50247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50248       };
50249     } catch (...) {
50250       {
50251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50252       };
50253     }
50254   }
50255
50256   jresult = (void *)result;
50257   return jresult;
50258 }
50259
50260
50261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50262   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50263   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50264
50265   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50266   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50267   if (!arg2) {
50268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50269     return ;
50270   }
50271   {
50272     try {
50273       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50274     } catch (std::out_of_range& e) {
50275       {
50276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50277       };
50278     } catch (std::exception& e) {
50279       {
50280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50281       };
50282     } catch (Dali::DaliException e) {
50283       {
50284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50285       };
50286     } catch (...) {
50287       {
50288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50289       };
50290     }
50291   }
50292
50293 }
50294
50295
50296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50297   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50298   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50299   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50300
50301   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50302   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50303   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50304   if (!arg3) {
50305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50306     return ;
50307   }
50308   {
50309     try {
50310       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50311     } catch (std::out_of_range& e) {
50312       {
50313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50314       };
50315     } catch (std::exception& e) {
50316       {
50317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50318       };
50319     } catch (Dali::DaliException e) {
50320       {
50321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50322       };
50323     } catch (...) {
50324       {
50325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50326       };
50327     }
50328   }
50329
50330 }
50331
50332
50333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50334   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50335   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50336   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50337   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50338
50339   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50340   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50341   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50342   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50343   {
50344     try {
50345       (arg1)->Insert(arg2,arg3,arg4);
50346     } catch (std::out_of_range& e) {
50347       {
50348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50349       };
50350     } catch (std::exception& e) {
50351       {
50352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50353       };
50354     } catch (Dali::DaliException e) {
50355       {
50356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50357       };
50358     } catch (...) {
50359       {
50360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50361       };
50362     }
50363   }
50364
50365 }
50366
50367
50368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50369   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50370   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50371
50372   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50373   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50374   {
50375     try {
50376       (arg1)->Reserve(arg2);
50377     } catch (std::out_of_range& e) {
50378       {
50379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50380       };
50381     } catch (std::exception& e) {
50382       {
50383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50384       };
50385     } catch (Dali::DaliException e) {
50386       {
50387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50388       };
50389     } catch (...) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50392       };
50393     }
50394   }
50395
50396 }
50397
50398
50399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50400   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50401   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50402
50403   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50404   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50405   {
50406     try {
50407       (arg1)->Resize(arg2);
50408     } catch (std::out_of_range& e) {
50409       {
50410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50411       };
50412     } catch (std::exception& e) {
50413       {
50414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50415       };
50416     } catch (Dali::DaliException e) {
50417       {
50418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50419       };
50420     } catch (...) {
50421       {
50422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50423       };
50424     }
50425   }
50426
50427 }
50428
50429
50430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50431   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50432   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50433   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50434
50435   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50436   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50437   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50438   if (!arg3) {
50439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50440     return ;
50441   }
50442   {
50443     try {
50444       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50445     } catch (std::out_of_range& e) {
50446       {
50447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50448       };
50449     } catch (std::exception& e) {
50450       {
50451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50452       };
50453     } catch (Dali::DaliException e) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50460       };
50461     }
50462   }
50463
50464 }
50465
50466
50467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50468   void * jresult ;
50469   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50470   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50471   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50472
50473   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50474   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50475   {
50476     try {
50477       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50478     } catch (std::out_of_range& e) {
50479       {
50480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50481       };
50482     } catch (std::exception& e) {
50483       {
50484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50485       };
50486     } catch (Dali::DaliException e) {
50487       {
50488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50489       };
50490     } catch (...) {
50491       {
50492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50493       };
50494     }
50495   }
50496
50497   jresult = (void *)result;
50498   return jresult;
50499 }
50500
50501
50502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50503   void * jresult ;
50504   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50505   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50506   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50507   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50508
50509   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50510   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50511   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50512   {
50513     try {
50514       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50515     } catch (std::out_of_range& e) {
50516       {
50517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50518       };
50519     } catch (std::exception& e) {
50520       {
50521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50522       };
50523     } catch (Dali::DaliException e) {
50524       {
50525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50526       };
50527     } catch (...) {
50528       {
50529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50530       };
50531     }
50532   }
50533
50534   jresult = (void *)result;
50535   return jresult;
50536 }
50537
50538
50539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50540   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50541   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50542
50543   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50544   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50545   {
50546     try {
50547       (arg1)->Remove(arg2);
50548     } catch (std::out_of_range& e) {
50549       {
50550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50551       };
50552     } catch (std::exception& e) {
50553       {
50554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50555       };
50556     } catch (Dali::DaliException e) {
50557       {
50558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50559       };
50560     } catch (...) {
50561       {
50562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50563       };
50564     }
50565   }
50566
50567 }
50568
50569
50570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50571   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50572   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50573
50574   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50575   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50576   if (!arg2) {
50577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50578     return ;
50579   }
50580   {
50581     try {
50582       (arg1)->Swap(*arg2);
50583     } catch (std::out_of_range& e) {
50584       {
50585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50586       };
50587     } catch (std::exception& e) {
50588       {
50589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50590       };
50591     } catch (Dali::DaliException e) {
50592       {
50593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50594       };
50595     } catch (...) {
50596       {
50597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50598       };
50599     }
50600   }
50601
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50606   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50607
50608   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50609   {
50610     try {
50611       (arg1)->Clear();
50612     } catch (std::out_of_range& e) {
50613       {
50614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50615       };
50616     } catch (std::exception& e) {
50617       {
50618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50619       };
50620     } catch (Dali::DaliException e) {
50621       {
50622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50623       };
50624     } catch (...) {
50625       {
50626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50627       };
50628     }
50629   }
50630
50631 }
50632
50633
50634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50635   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50636
50637   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50638   {
50639     try {
50640       (arg1)->Release();
50641     } catch (std::out_of_range& e) {
50642       {
50643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50644       };
50645     } catch (std::exception& e) {
50646       {
50647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50648       };
50649     } catch (Dali::DaliException e) {
50650       {
50651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50652       };
50653     } catch (...) {
50654       {
50655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50656       };
50657     }
50658   }
50659
50660 }
50661
50662
50663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50664   void * jresult ;
50665   Dali::Signal< void () > *result = 0 ;
50666
50667   {
50668     try {
50669       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50670     } catch (std::out_of_range& e) {
50671       {
50672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50673       };
50674     } catch (std::exception& e) {
50675       {
50676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50677       };
50678     } catch (Dali::DaliException e) {
50679       {
50680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50681       };
50682     } catch (...) {
50683       {
50684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50685       };
50686     }
50687   }
50688
50689   jresult = (void *)result;
50690   return jresult;
50691 }
50692
50693
50694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50695   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50696
50697   arg1 = (Dali::Signal< void () > *)jarg1;
50698   {
50699     try {
50700       delete arg1;
50701     } catch (std::out_of_range& e) {
50702       {
50703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (std::exception& e) {
50706       {
50707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50708       };
50709     } catch (Dali::DaliException e) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50712       };
50713     } catch (...) {
50714       {
50715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50716       };
50717     }
50718   }
50719
50720 }
50721
50722
50723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50724   unsigned int jresult ;
50725   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50726   bool result;
50727
50728   arg1 = (Dali::Signal< void () > *)jarg1;
50729   {
50730     try {
50731       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50732     } catch (std::out_of_range& e) {
50733       {
50734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50735       };
50736     } catch (std::exception& e) {
50737       {
50738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50739       };
50740     } catch (Dali::DaliException e) {
50741       {
50742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50743       };
50744     } catch (...) {
50745       {
50746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50747       };
50748     }
50749   }
50750
50751   jresult = result;
50752   return jresult;
50753 }
50754
50755
50756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50757   unsigned long jresult ;
50758   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50759   std::size_t result;
50760
50761   arg1 = (Dali::Signal< void () > *)jarg1;
50762   {
50763     try {
50764       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50765     } catch (std::out_of_range& e) {
50766       {
50767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50768       };
50769     } catch (std::exception& e) {
50770       {
50771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50772       };
50773     } catch (Dali::DaliException e) {
50774       {
50775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50776       };
50777     } catch (...) {
50778       {
50779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50780       };
50781     }
50782   }
50783
50784   jresult = (unsigned long)result;
50785   return jresult;
50786 }
50787
50788
50789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50790   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50791   void (*arg2)() = (void (*)()) 0 ;
50792
50793   arg1 = (Dali::Signal< void () > *)jarg1;
50794   arg2 = (void (*)())jarg2;
50795   {
50796     try {
50797       (arg1)->Connect(arg2);
50798     } catch (std::out_of_range& e) {
50799       {
50800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50801       };
50802     } catch (std::exception& e) {
50803       {
50804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50805       };
50806     } catch (Dali::DaliException e) {
50807       {
50808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50809       };
50810     } catch (...) {
50811       {
50812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50813       };
50814     }
50815   }
50816
50817 }
50818
50819
50820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50821   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50822   void (*arg2)() = (void (*)()) 0 ;
50823
50824   arg1 = (Dali::Signal< void () > *)jarg1;
50825   arg2 = (void (*)())jarg2;
50826   {
50827     try {
50828       (arg1)->Disconnect(arg2);
50829     } catch (std::out_of_range& e) {
50830       {
50831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50832       };
50833     } catch (std::exception& e) {
50834       {
50835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50836       };
50837     } catch (Dali::DaliException e) {
50838       {
50839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50840       };
50841     } catch (...) {
50842       {
50843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50844       };
50845     }
50846   }
50847
50848 }
50849
50850
50851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50852   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50853   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50854   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50855
50856   arg1 = (Dali::Signal< void () > *)jarg1;
50857   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50858   arg3 = (Dali::FunctorDelegate *)jarg3;
50859   {
50860     try {
50861       (arg1)->Connect(arg2,arg3);
50862     } catch (std::out_of_range& e) {
50863       {
50864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50865       };
50866     } catch (std::exception& e) {
50867       {
50868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50869       };
50870     } catch (Dali::DaliException e) {
50871       {
50872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50873       };
50874     } catch (...) {
50875       {
50876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50877       };
50878     }
50879   }
50880
50881 }
50882
50883
50884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50885   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50886
50887   arg1 = (Dali::Signal< void () > *)jarg1;
50888   {
50889     try {
50890       (arg1)->Emit();
50891     } catch (std::out_of_range& e) {
50892       {
50893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50894       };
50895     } catch (std::exception& e) {
50896       {
50897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50898       };
50899     } catch (Dali::DaliException e) {
50900       {
50901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50902       };
50903     } catch (...) {
50904       {
50905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50906       };
50907     }
50908   }
50909
50910 }
50911
50912
50913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50914   unsigned int jresult ;
50915   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50916   bool result;
50917
50918   arg1 = (Dali::Signal< void (float) > *)jarg1;
50919   {
50920     try {
50921       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50922     } catch (std::out_of_range& e) {
50923       {
50924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50925       };
50926     } catch (std::exception& e) {
50927       {
50928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50929       };
50930     } catch (Dali::DaliException e) {
50931       {
50932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50933       };
50934     } catch (...) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50937       };
50938     }
50939   }
50940
50941   jresult = result;
50942   return jresult;
50943 }
50944
50945
50946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50947   unsigned long jresult ;
50948   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50949   std::size_t result;
50950
50951   arg1 = (Dali::Signal< void (float) > *)jarg1;
50952   {
50953     try {
50954       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50955     } catch (std::out_of_range& e) {
50956       {
50957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50958       };
50959     } catch (std::exception& e) {
50960       {
50961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50962       };
50963     } catch (Dali::DaliException e) {
50964       {
50965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50966       };
50967     } catch (...) {
50968       {
50969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50970       };
50971     }
50972   }
50973
50974   jresult = (unsigned long)result;
50975   return jresult;
50976 }
50977
50978
50979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50980   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50981   void (*arg2)(float) = (void (*)(float)) 0 ;
50982
50983   arg1 = (Dali::Signal< void (float) > *)jarg1;
50984   arg2 = (void (*)(float))jarg2;
50985   {
50986     try {
50987       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50988     } catch (std::out_of_range& e) {
50989       {
50990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50991       };
50992     } catch (std::exception& e) {
50993       {
50994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (Dali::DaliException e) {
50997       {
50998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50999       };
51000     } catch (...) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51003       };
51004     }
51005   }
51006
51007 }
51008
51009
51010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
51011   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51012   void (*arg2)(float) = (void (*)(float)) 0 ;
51013
51014   arg1 = (Dali::Signal< void (float) > *)jarg1;
51015   arg2 = (void (*)(float))jarg2;
51016   {
51017     try {
51018       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
51019     } catch (std::out_of_range& e) {
51020       {
51021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51022       };
51023     } catch (std::exception& e) {
51024       {
51025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51026       };
51027     } catch (Dali::DaliException e) {
51028       {
51029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51030       };
51031     } catch (...) {
51032       {
51033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51034       };
51035     }
51036   }
51037
51038 }
51039
51040
51041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
51042   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51043   float arg2 ;
51044
51045   arg1 = (Dali::Signal< void (float) > *)jarg1;
51046   arg2 = (float)jarg2;
51047   {
51048     try {
51049       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
51050     } catch (std::out_of_range& e) {
51051       {
51052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51053       };
51054     } catch (std::exception& e) {
51055       {
51056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51057       };
51058     } catch (Dali::DaliException e) {
51059       {
51060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51061       };
51062     } catch (...) {
51063       {
51064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51065       };
51066     }
51067   }
51068
51069 }
51070
51071
51072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
51073   void * jresult ;
51074   Dali::Signal< void (float) > *result = 0 ;
51075
51076   {
51077     try {
51078       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
51079     } catch (std::out_of_range& e) {
51080       {
51081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51082       };
51083     } catch (std::exception& e) {
51084       {
51085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51086       };
51087     } catch (Dali::DaliException e) {
51088       {
51089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51090       };
51091     } catch (...) {
51092       {
51093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51094       };
51095     }
51096   }
51097
51098   jresult = (void *)result;
51099   return jresult;
51100 }
51101
51102
51103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
51104   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51105
51106   arg1 = (Dali::Signal< void (float) > *)jarg1;
51107   {
51108     try {
51109       delete arg1;
51110     } catch (std::out_of_range& e) {
51111       {
51112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51113       };
51114     } catch (std::exception& e) {
51115       {
51116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51117       };
51118     } catch (Dali::DaliException e) {
51119       {
51120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51121       };
51122     } catch (...) {
51123       {
51124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51125       };
51126     }
51127   }
51128
51129 }
51130
51131
51132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
51133   unsigned int jresult ;
51134   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51135   bool result;
51136
51137   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51138   {
51139     try {
51140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51141     } catch (std::out_of_range& e) {
51142       {
51143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51144       };
51145     } catch (std::exception& e) {
51146       {
51147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (Dali::DaliException e) {
51150       {
51151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51156       };
51157     }
51158   }
51159
51160   jresult = result;
51161   return jresult;
51162 }
51163
51164
51165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
51166   unsigned long jresult ;
51167   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51168   std::size_t result;
51169
51170   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51171   {
51172     try {
51173       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51174     } catch (std::out_of_range& e) {
51175       {
51176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51177       };
51178     } catch (std::exception& e) {
51179       {
51180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51181       };
51182     } catch (Dali::DaliException e) {
51183       {
51184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51185       };
51186     } catch (...) {
51187       {
51188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51189       };
51190     }
51191   }
51192
51193   jresult = (unsigned long)result;
51194   return jresult;
51195 }
51196
51197
51198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51199   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51200   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51201
51202   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51203   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51204   {
51205     try {
51206       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51207     } catch (std::out_of_range& e) {
51208       {
51209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51210       };
51211     } catch (std::exception& e) {
51212       {
51213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51214       };
51215     } catch (Dali::DaliException e) {
51216       {
51217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51218       };
51219     } catch (...) {
51220       {
51221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51222       };
51223     }
51224   }
51225
51226 }
51227
51228
51229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51230   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51231   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51232
51233   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51234   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51235   {
51236     try {
51237       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51238     } catch (std::out_of_range& e) {
51239       {
51240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51241       };
51242     } catch (std::exception& e) {
51243       {
51244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51245       };
51246     } catch (Dali::DaliException e) {
51247       {
51248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51249       };
51250     } catch (...) {
51251       {
51252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51253       };
51254     }
51255   }
51256
51257 }
51258
51259
51260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51261   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51262   Dali::BaseHandle arg2 ;
51263   Dali::BaseHandle *argp2 ;
51264
51265   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51266   argp2 = (Dali::BaseHandle *)jarg2;
51267   if (!argp2) {
51268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51269     return ;
51270   }
51271   arg2 = *argp2;
51272   {
51273     try {
51274       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51275     } catch (std::out_of_range& e) {
51276       {
51277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51278       };
51279     } catch (std::exception& e) {
51280       {
51281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (Dali::DaliException e) {
51284       {
51285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293
51294 }
51295
51296
51297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51298   void * jresult ;
51299   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51300
51301   {
51302     try {
51303       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51304     } catch (std::out_of_range& e) {
51305       {
51306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51307       };
51308     } catch (std::exception& e) {
51309       {
51310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51311       };
51312     } catch (Dali::DaliException e) {
51313       {
51314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51315       };
51316     } catch (...) {
51317       {
51318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51319       };
51320     }
51321   }
51322
51323   jresult = (void *)result;
51324   return jresult;
51325 }
51326
51327
51328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51329   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51330
51331   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51332   {
51333     try {
51334       delete arg1;
51335     } catch (std::out_of_range& e) {
51336       {
51337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51338       };
51339     } catch (std::exception& e) {
51340       {
51341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51342       };
51343     } catch (Dali::DaliException e) {
51344       {
51345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51346       };
51347     } catch (...) {
51348       {
51349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51350       };
51351     }
51352   }
51353
51354 }
51355
51356
51357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51358   unsigned int jresult ;
51359   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51360   bool result;
51361
51362   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51363   {
51364     try {
51365       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51366     } catch (std::out_of_range& e) {
51367       {
51368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51369       };
51370     } catch (std::exception& e) {
51371       {
51372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51373       };
51374     } catch (Dali::DaliException e) {
51375       {
51376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51377       };
51378     } catch (...) {
51379       {
51380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51381       };
51382     }
51383   }
51384
51385   jresult = result;
51386   return jresult;
51387 }
51388
51389
51390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51391   unsigned long jresult ;
51392   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51393   std::size_t result;
51394
51395   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51396   {
51397     try {
51398       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51399     } catch (std::out_of_range& e) {
51400       {
51401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51402       };
51403     } catch (std::exception& e) {
51404       {
51405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51406       };
51407     } catch (Dali::DaliException e) {
51408       {
51409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51410       };
51411     } catch (...) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51414       };
51415     }
51416   }
51417
51418   jresult = (unsigned long)result;
51419   return jresult;
51420 }
51421
51422
51423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51424   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51425   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51426
51427   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51428   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51429   {
51430     try {
51431       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51432     } catch (std::out_of_range& e) {
51433       {
51434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51435       };
51436     } catch (std::exception& e) {
51437       {
51438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51439       };
51440     } catch (Dali::DaliException e) {
51441       {
51442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51443       };
51444     } catch (...) {
51445       {
51446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51447       };
51448     }
51449   }
51450
51451 }
51452
51453
51454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51455   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51456   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51457
51458   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51459   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51460   {
51461     try {
51462       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51463     } catch (std::out_of_range& e) {
51464       {
51465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51466       };
51467     } catch (std::exception& e) {
51468       {
51469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (Dali::DaliException e) {
51472       {
51473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481
51482 }
51483
51484
51485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51486   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51487   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51488
51489   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51490   arg2 = (Dali::RefObject *)jarg2;
51491   {
51492     try {
51493       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51494     } catch (std::out_of_range& e) {
51495       {
51496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51497       };
51498     } catch (std::exception& e) {
51499       {
51500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (Dali::DaliException e) {
51503       {
51504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512
51513 }
51514
51515
51516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51517   void * jresult ;
51518   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51519
51520   {
51521     try {
51522       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51523     } catch (std::out_of_range& e) {
51524       {
51525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51526       };
51527     } catch (std::exception& e) {
51528       {
51529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51530       };
51531     } catch (Dali::DaliException e) {
51532       {
51533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51534       };
51535     } catch (...) {
51536       {
51537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51538       };
51539     }
51540   }
51541
51542   jresult = (void *)result;
51543   return jresult;
51544 }
51545
51546
51547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51548   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51549
51550   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51551   {
51552     try {
51553       delete arg1;
51554     } catch (std::out_of_range& e) {
51555       {
51556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51557       };
51558     } catch (std::exception& e) {
51559       {
51560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51561       };
51562     } catch (Dali::DaliException e) {
51563       {
51564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51565       };
51566     } catch (...) {
51567       {
51568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51569       };
51570     }
51571   }
51572
51573 }
51574
51575
51576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51577   unsigned int jresult ;
51578   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51579   bool result;
51580
51581   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51582   {
51583     try {
51584       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51585     } catch (std::out_of_range& e) {
51586       {
51587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51588       };
51589     } catch (std::exception& e) {
51590       {
51591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51592       };
51593     } catch (Dali::DaliException e) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51596       };
51597     } catch (...) {
51598       {
51599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51600       };
51601     }
51602   }
51603
51604   jresult = result;
51605   return jresult;
51606 }
51607
51608
51609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51610   unsigned long jresult ;
51611   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51612   std::size_t result;
51613
51614   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51615   {
51616     try {
51617       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51618     } catch (std::out_of_range& e) {
51619       {
51620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51621       };
51622     } catch (std::exception& e) {
51623       {
51624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51625       };
51626     } catch (Dali::DaliException e) {
51627       {
51628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51629       };
51630     } catch (...) {
51631       {
51632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51633       };
51634     }
51635   }
51636
51637   jresult = (unsigned long)result;
51638   return jresult;
51639 }
51640
51641
51642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51643   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51644   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51645
51646   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51647   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51648   {
51649     try {
51650       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51651     } catch (std::out_of_range& e) {
51652       {
51653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51654       };
51655     } catch (std::exception& e) {
51656       {
51657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51658       };
51659     } catch (Dali::DaliException e) {
51660       {
51661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51662       };
51663     } catch (...) {
51664       {
51665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51666       };
51667     }
51668   }
51669
51670 }
51671
51672
51673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51674   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51675   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51676
51677   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51678   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51679   {
51680     try {
51681       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51682     } catch (std::out_of_range& e) {
51683       {
51684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51685       };
51686     } catch (std::exception& e) {
51687       {
51688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51689       };
51690     } catch (Dali::DaliException e) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51693       };
51694     } catch (...) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51697       };
51698     }
51699   }
51700
51701 }
51702
51703
51704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51705   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51706   Dali::PropertyNotification *arg2 = 0 ;
51707
51708   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51709   arg2 = (Dali::PropertyNotification *)jarg2;
51710   if (!arg2) {
51711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51712     return ;
51713   }
51714   {
51715     try {
51716       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51717     } catch (std::out_of_range& e) {
51718       {
51719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (std::exception& e) {
51722       {
51723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51724       };
51725     } catch (Dali::DaliException e) {
51726       {
51727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51728       };
51729     } catch (...) {
51730       {
51731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51732       };
51733     }
51734   }
51735
51736 }
51737
51738
51739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51740   void * jresult ;
51741   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51742
51743   {
51744     try {
51745       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51746     } catch (std::out_of_range& e) {
51747       {
51748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51749       };
51750     } catch (std::exception& e) {
51751       {
51752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51753       };
51754     } catch (Dali::DaliException e) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51757       };
51758     } catch (...) {
51759       {
51760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51761       };
51762     }
51763   }
51764
51765   jresult = (void *)result;
51766   return jresult;
51767 }
51768
51769
51770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51771   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51772
51773   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51774   {
51775     try {
51776       delete arg1;
51777     } catch (std::out_of_range& e) {
51778       {
51779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51780       };
51781     } catch (std::exception& e) {
51782       {
51783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51784       };
51785     } catch (Dali::DaliException e) {
51786       {
51787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51792       };
51793     }
51794   }
51795
51796 }
51797
51798
51799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51800   void * jresult ;
51801   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51802
51803   {
51804     try {
51805       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51806     } catch (std::out_of_range& e) {
51807       {
51808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51809       };
51810     } catch (std::exception& e) {
51811       {
51812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51813       };
51814     } catch (Dali::DaliException e) {
51815       {
51816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51817       };
51818     } catch (...) {
51819       {
51820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51821       };
51822     }
51823   }
51824
51825   jresult = (void *)result;
51826   return jresult;
51827 }
51828
51829
51830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51831   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51832
51833   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51834   {
51835     try {
51836       delete arg1;
51837     } catch (std::out_of_range& e) {
51838       {
51839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51840       };
51841     } catch (std::exception& e) {
51842       {
51843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51844       };
51845     } catch (Dali::DaliException e) {
51846       {
51847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51848       };
51849     } catch (...) {
51850       {
51851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51852       };
51853     }
51854   }
51855
51856 }
51857
51858
51859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51860   unsigned int jresult ;
51861   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51862   bool result;
51863
51864   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51865   {
51866     try {
51867       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);
51868     } catch (std::out_of_range& e) {
51869       {
51870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51871       };
51872     } catch (std::exception& e) {
51873       {
51874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51875       };
51876     } catch (Dali::DaliException e) {
51877       {
51878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51879       };
51880     } catch (...) {
51881       {
51882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51883       };
51884     }
51885   }
51886
51887   jresult = result;
51888   return jresult;
51889 }
51890
51891
51892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51893   unsigned long jresult ;
51894   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51895   std::size_t result;
51896
51897   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51898   {
51899     try {
51900       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);
51901     } catch (std::out_of_range& e) {
51902       {
51903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51904       };
51905     } catch (std::exception& e) {
51906       {
51907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51908       };
51909     } catch (Dali::DaliException e) {
51910       {
51911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51912       };
51913     } catch (...) {
51914       {
51915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51916       };
51917     }
51918   }
51919
51920   jresult = (unsigned long)result;
51921   return jresult;
51922 }
51923
51924
51925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51926   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51927   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51928
51929   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51930   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51931   {
51932     try {
51933       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51934     } catch (std::out_of_range& e) {
51935       {
51936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51937       };
51938     } catch (std::exception& e) {
51939       {
51940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51941       };
51942     } catch (Dali::DaliException e) {
51943       {
51944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51945       };
51946     } catch (...) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51949       };
51950     }
51951   }
51952
51953 }
51954
51955
51956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51957   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51958   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51959
51960   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51961   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51962   {
51963     try {
51964       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51972       };
51973     } catch (Dali::DaliException e) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51976       };
51977     } catch (...) {
51978       {
51979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51980       };
51981     }
51982   }
51983
51984 }
51985
51986
51987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51988   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51989   Dali::Actor arg2 ;
51990   Dali::LongPressGesture *arg3 = 0 ;
51991   Dali::Actor *argp2 ;
51992
51993   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51994   argp2 = (Dali::Actor *)jarg2;
51995   if (!argp2) {
51996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51997     return ;
51998   }
51999   arg2 = *argp2;
52000   arg3 = (Dali::LongPressGesture *)jarg3;
52001   if (!arg3) {
52002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
52003     return ;
52004   }
52005   {
52006     try {
52007       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
52008     } catch (std::out_of_range& e) {
52009       {
52010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52011       };
52012     } catch (std::exception& e) {
52013       {
52014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52015       };
52016     } catch (Dali::DaliException e) {
52017       {
52018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52019       };
52020     } catch (...) {
52021       {
52022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52023       };
52024     }
52025   }
52026
52027 }
52028
52029
52030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
52031   void * jresult ;
52032   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
52033
52034   {
52035     try {
52036       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
52037     } catch (std::out_of_range& e) {
52038       {
52039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52040       };
52041     } catch (std::exception& e) {
52042       {
52043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52044       };
52045     } catch (Dali::DaliException e) {
52046       {
52047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52048       };
52049     } catch (...) {
52050       {
52051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52052       };
52053     }
52054   }
52055
52056   jresult = (void *)result;
52057   return jresult;
52058 }
52059
52060
52061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
52062   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52063
52064   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52065   {
52066     try {
52067       delete arg1;
52068     } catch (std::out_of_range& e) {
52069       {
52070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52071       };
52072     } catch (std::exception& e) {
52073       {
52074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52075       };
52076     } catch (Dali::DaliException e) {
52077       {
52078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52079       };
52080     } catch (...) {
52081       {
52082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52083       };
52084     }
52085   }
52086
52087 }
52088
52089
52090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
52091   unsigned int jresult ;
52092   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52093   bool result;
52094
52095   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52096   {
52097     try {
52098       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);
52099     } catch (std::out_of_range& e) {
52100       {
52101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52102       };
52103     } catch (std::exception& e) {
52104       {
52105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52106       };
52107     } catch (Dali::DaliException e) {
52108       {
52109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52110       };
52111     } catch (...) {
52112       {
52113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52114       };
52115     }
52116   }
52117
52118   jresult = result;
52119   return jresult;
52120 }
52121
52122
52123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
52124   unsigned long jresult ;
52125   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52126   std::size_t result;
52127
52128   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52129   {
52130     try {
52131       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);
52132     } catch (std::out_of_range& e) {
52133       {
52134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52135       };
52136     } catch (std::exception& e) {
52137       {
52138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52139       };
52140     } catch (Dali::DaliException e) {
52141       {
52142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52143       };
52144     } catch (...) {
52145       {
52146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52147       };
52148     }
52149   }
52150
52151   jresult = (unsigned long)result;
52152   return jresult;
52153 }
52154
52155
52156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
52157   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52158   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
52159
52160   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52161   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
52162   {
52163     try {
52164       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52165     } catch (std::out_of_range& e) {
52166       {
52167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52168       };
52169     } catch (std::exception& e) {
52170       {
52171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52172       };
52173     } catch (Dali::DaliException e) {
52174       {
52175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52176       };
52177     } catch (...) {
52178       {
52179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52180       };
52181     }
52182   }
52183
52184 }
52185
52186
52187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52188   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52189   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
52190
52191   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52192   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
52193   {
52194     try {
52195       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52196     } catch (std::out_of_range& e) {
52197       {
52198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52199       };
52200     } catch (std::exception& e) {
52201       {
52202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52203       };
52204     } catch (Dali::DaliException e) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52207       };
52208     } catch (...) {
52209       {
52210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52211       };
52212     }
52213   }
52214
52215 }
52216
52217
52218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52219   unsigned int jresult ;
52220   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52221   Dali::Actor arg2 ;
52222   Dali::TouchEvent *arg3 = 0 ;
52223   Dali::Actor *argp2 ;
52224   bool result;
52225
52226   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52227   argp2 = (Dali::Actor *)jarg2;
52228   if (!argp2) {
52229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52230     return 0;
52231   }
52232   arg2 = *argp2;
52233   arg3 = (Dali::TouchEvent *)jarg3;
52234   if (!arg3) {
52235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
52236     return 0;
52237   }
52238   {
52239     try {
52240       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
52241     } catch (std::out_of_range& e) {
52242       {
52243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52244       };
52245     } catch (std::exception& e) {
52246       {
52247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (Dali::DaliException e) {
52250       {
52251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52252       };
52253     } catch (...) {
52254       {
52255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52256       };
52257     }
52258   }
52259
52260   jresult = result;
52261   return jresult;
52262 }
52263
52264
52265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52266   void * jresult ;
52267   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
52268
52269   {
52270     try {
52271       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
52272     } catch (std::out_of_range& e) {
52273       {
52274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52275       };
52276     } catch (std::exception& e) {
52277       {
52278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52279       };
52280     } catch (Dali::DaliException e) {
52281       {
52282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52283       };
52284     } catch (...) {
52285       {
52286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52287       };
52288     }
52289   }
52290
52291   jresult = (void *)result;
52292   return jresult;
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52297   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52298
52299   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52300   {
52301     try {
52302       delete arg1;
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52310       };
52311     } catch (Dali::DaliException e) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52314       };
52315     } catch (...) {
52316       {
52317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52318       };
52319     }
52320   }
52321
52322 }
52323
52324
52325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52326   unsigned int jresult ;
52327   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52328   bool result;
52329
52330   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52331   {
52332     try {
52333       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);
52334     } catch (std::out_of_range& e) {
52335       {
52336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52337       };
52338     } catch (std::exception& e) {
52339       {
52340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52341       };
52342     } catch (Dali::DaliException e) {
52343       {
52344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52345       };
52346     } catch (...) {
52347       {
52348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52349       };
52350     }
52351   }
52352
52353   jresult = result;
52354   return jresult;
52355 }
52356
52357
52358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52359   unsigned long jresult ;
52360   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52361   std::size_t result;
52362
52363   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52364   {
52365     try {
52366       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);
52367     } catch (std::out_of_range& e) {
52368       {
52369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52370       };
52371     } catch (std::exception& e) {
52372       {
52373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52374       };
52375     } catch (Dali::DaliException e) {
52376       {
52377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52378       };
52379     } catch (...) {
52380       {
52381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52382       };
52383     }
52384   }
52385
52386   jresult = (unsigned long)result;
52387   return jresult;
52388 }
52389
52390
52391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52392   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52393   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52394
52395   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52396   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52397   {
52398     try {
52399       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52400     } catch (std::out_of_range& e) {
52401       {
52402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52403       };
52404     } catch (std::exception& e) {
52405       {
52406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52407       };
52408     } catch (Dali::DaliException e) {
52409       {
52410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52411       };
52412     } catch (...) {
52413       {
52414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52415       };
52416     }
52417   }
52418
52419 }
52420
52421
52422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52423   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52424   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52425
52426   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52427   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52428   {
52429     try {
52430       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52431     } catch (std::out_of_range& e) {
52432       {
52433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52434       };
52435     } catch (std::exception& e) {
52436       {
52437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52438       };
52439     } catch (Dali::DaliException e) {
52440       {
52441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52442       };
52443     } catch (...) {
52444       {
52445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52446       };
52447     }
52448   }
52449
52450 }
52451
52452
52453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52454   unsigned int jresult ;
52455   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52456   Dali::Actor arg2 ;
52457   Dali::HoverEvent *arg3 = 0 ;
52458   Dali::Actor *argp2 ;
52459   bool result;
52460
52461   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52462   argp2 = (Dali::Actor *)jarg2;
52463   if (!argp2) {
52464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52465     return 0;
52466   }
52467   arg2 = *argp2;
52468   arg3 = (Dali::HoverEvent *)jarg3;
52469   if (!arg3) {
52470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52471     return 0;
52472   }
52473   {
52474     try {
52475       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52476     } catch (std::out_of_range& e) {
52477       {
52478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52479       };
52480     } catch (std::exception& e) {
52481       {
52482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52483       };
52484     } catch (Dali::DaliException e) {
52485       {
52486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52487       };
52488     } catch (...) {
52489       {
52490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52491       };
52492     }
52493   }
52494
52495   jresult = result;
52496   return jresult;
52497 }
52498
52499
52500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52501   void * jresult ;
52502   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52503
52504   {
52505     try {
52506       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52507     } catch (std::out_of_range& e) {
52508       {
52509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52510       };
52511     } catch (std::exception& e) {
52512       {
52513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52514       };
52515     } catch (Dali::DaliException e) {
52516       {
52517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52518       };
52519     } catch (...) {
52520       {
52521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52522       };
52523     }
52524   }
52525
52526   jresult = (void *)result;
52527   return jresult;
52528 }
52529
52530
52531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52532   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52533
52534   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52535   {
52536     try {
52537       delete arg1;
52538     } catch (std::out_of_range& e) {
52539       {
52540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52541       };
52542     } catch (std::exception& e) {
52543       {
52544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52545       };
52546     } catch (Dali::DaliException e) {
52547       {
52548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52549       };
52550     } catch (...) {
52551       {
52552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52553       };
52554     }
52555   }
52556
52557 }
52558
52559
52560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52561   unsigned int jresult ;
52562   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52563   bool result;
52564
52565   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52566   {
52567     try {
52568       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);
52569     } catch (std::out_of_range& e) {
52570       {
52571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52572       };
52573     } catch (std::exception& e) {
52574       {
52575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52576       };
52577     } catch (Dali::DaliException e) {
52578       {
52579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52584       };
52585     }
52586   }
52587
52588   jresult = result;
52589   return jresult;
52590 }
52591
52592
52593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52594   unsigned long jresult ;
52595   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52596   std::size_t result;
52597
52598   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52599   {
52600     try {
52601       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);
52602     } catch (std::out_of_range& e) {
52603       {
52604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52605       };
52606     } catch (std::exception& e) {
52607       {
52608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52609       };
52610     } catch (Dali::DaliException e) {
52611       {
52612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52613       };
52614     } catch (...) {
52615       {
52616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52617       };
52618     }
52619   }
52620
52621   jresult = (unsigned long)result;
52622   return jresult;
52623 }
52624
52625
52626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52627   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52628   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52629
52630   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52631   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52632   {
52633     try {
52634       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52635     } catch (std::out_of_range& e) {
52636       {
52637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (std::exception& e) {
52640       {
52641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52642       };
52643     } catch (Dali::DaliException e) {
52644       {
52645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52646       };
52647     } catch (...) {
52648       {
52649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52650       };
52651     }
52652   }
52653
52654 }
52655
52656
52657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52658   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52659   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52660
52661   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52662   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52663   {
52664     try {
52665       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52666     } catch (std::out_of_range& e) {
52667       {
52668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52669       };
52670     } catch (std::exception& e) {
52671       {
52672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52673       };
52674     } catch (Dali::DaliException e) {
52675       {
52676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52677       };
52678     } catch (...) {
52679       {
52680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52681       };
52682     }
52683   }
52684
52685 }
52686
52687
52688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52689   unsigned int jresult ;
52690   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52691   Dali::Actor arg2 ;
52692   Dali::WheelEvent *arg3 = 0 ;
52693   Dali::Actor *argp2 ;
52694   bool result;
52695
52696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52697   argp2 = (Dali::Actor *)jarg2;
52698   if (!argp2) {
52699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52700     return 0;
52701   }
52702   arg2 = *argp2;
52703   arg3 = (Dali::WheelEvent *)jarg3;
52704   if (!arg3) {
52705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52706     return 0;
52707   }
52708   {
52709     try {
52710       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52711     } catch (std::out_of_range& e) {
52712       {
52713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (std::exception& e) {
52716       {
52717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52718       };
52719     } catch (Dali::DaliException e) {
52720       {
52721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52722       };
52723     } catch (...) {
52724       {
52725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52726       };
52727     }
52728   }
52729
52730   jresult = result;
52731   return jresult;
52732 }
52733
52734
52735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52736   void * jresult ;
52737   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52738
52739   {
52740     try {
52741       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52742     } catch (std::out_of_range& e) {
52743       {
52744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52745       };
52746     } catch (std::exception& e) {
52747       {
52748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52749       };
52750     } catch (Dali::DaliException e) {
52751       {
52752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52753       };
52754     } catch (...) {
52755       {
52756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52757       };
52758     }
52759   }
52760
52761   jresult = (void *)result;
52762   return jresult;
52763 }
52764
52765
52766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52767   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52768
52769   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52770   {
52771     try {
52772       delete arg1;
52773     } catch (std::out_of_range& e) {
52774       {
52775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52776       };
52777     } catch (std::exception& e) {
52778       {
52779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52780       };
52781     } catch (Dali::DaliException e) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52784       };
52785     } catch (...) {
52786       {
52787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52788       };
52789     }
52790   }
52791
52792 }
52793
52794
52795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52796   unsigned int jresult ;
52797   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52798   bool result;
52799
52800   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52801   {
52802     try {
52803       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52804     } catch (std::out_of_range& e) {
52805       {
52806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52807       };
52808     } catch (std::exception& e) {
52809       {
52810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52811       };
52812     } catch (Dali::DaliException e) {
52813       {
52814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52815       };
52816     } catch (...) {
52817       {
52818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52819       };
52820     }
52821   }
52822
52823   jresult = result;
52824   return jresult;
52825 }
52826
52827
52828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52829   unsigned long jresult ;
52830   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52831   std::size_t result;
52832
52833   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52834   {
52835     try {
52836       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52837     } catch (std::out_of_range& e) {
52838       {
52839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52840       };
52841     } catch (std::exception& e) {
52842       {
52843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52844       };
52845     } catch (Dali::DaliException e) {
52846       {
52847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52848       };
52849     } catch (...) {
52850       {
52851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52852       };
52853     }
52854   }
52855
52856   jresult = (unsigned long)result;
52857   return jresult;
52858 }
52859
52860
52861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52862   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52863   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52864
52865   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52866   arg2 = (void (*)(Dali::Actor))jarg2;
52867   {
52868     try {
52869       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52870     } catch (std::out_of_range& e) {
52871       {
52872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52873       };
52874     } catch (std::exception& e) {
52875       {
52876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52877       };
52878     } catch (Dali::DaliException e) {
52879       {
52880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52881       };
52882     } catch (...) {
52883       {
52884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52885       };
52886     }
52887   }
52888
52889 }
52890
52891
52892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52894   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52895
52896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52897   arg2 = (void (*)(Dali::Actor))jarg2;
52898   {
52899     try {
52900       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52908       };
52909     } catch (Dali::DaliException e) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52912       };
52913     } catch (...) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52916       };
52917     }
52918   }
52919
52920 }
52921
52922
52923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52924   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52925   Dali::Actor arg2 ;
52926   Dali::Actor *argp2 ;
52927
52928   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52929   argp2 = (Dali::Actor *)jarg2;
52930   if (!argp2) {
52931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52932     return ;
52933   }
52934   arg2 = *argp2;
52935   {
52936     try {
52937       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52938     } catch (std::out_of_range& e) {
52939       {
52940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52941       };
52942     } catch (std::exception& e) {
52943       {
52944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52945       };
52946     } catch (Dali::DaliException e) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52949       };
52950     } catch (...) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52953       };
52954     }
52955   }
52956
52957 }
52958
52959
52960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52961   void * jresult ;
52962   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52963
52964   {
52965     try {
52966       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (Dali::DaliException e) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52982       };
52983     }
52984   }
52985
52986   jresult = (void *)result;
52987   return jresult;
52988 }
52989
52990
52991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52992   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52993
52994   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52995   {
52996     try {
52997       delete arg1;
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (Dali::DaliException e) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53009       };
53010     } catch (...) {
53011       {
53012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53013       };
53014     }
53015   }
53016
53017 }
53018
53019
53020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
53021   unsigned int jresult ;
53022   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53023   bool result;
53024
53025   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53026   {
53027     try {
53028       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53029     } catch (std::out_of_range& e) {
53030       {
53031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53032       };
53033     } catch (std::exception& e) {
53034       {
53035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53036       };
53037     } catch (Dali::DaliException e) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53040       };
53041     } catch (...) {
53042       {
53043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53044       };
53045     }
53046   }
53047
53048   jresult = result;
53049   return jresult;
53050 }
53051
53052
53053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
53054   unsigned long jresult ;
53055   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53056   std::size_t result;
53057
53058   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53059   {
53060     try {
53061       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53062     } catch (std::out_of_range& e) {
53063       {
53064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53065       };
53066     } catch (std::exception& e) {
53067       {
53068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53069       };
53070     } catch (Dali::DaliException e) {
53071       {
53072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53073       };
53074     } catch (...) {
53075       {
53076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53077       };
53078     }
53079   }
53080
53081   jresult = (unsigned long)result;
53082   return jresult;
53083 }
53084
53085
53086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
53087   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53088   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53089
53090   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53091   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53092   {
53093     try {
53094       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53095     } catch (std::out_of_range& e) {
53096       {
53097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53098       };
53099     } catch (std::exception& e) {
53100       {
53101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53102       };
53103     } catch (Dali::DaliException e) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53106       };
53107     } catch (...) {
53108       {
53109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53110       };
53111     }
53112   }
53113
53114 }
53115
53116
53117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
53118   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53119   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53120
53121   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53122   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53123   {
53124     try {
53125       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53126     } catch (std::out_of_range& e) {
53127       {
53128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53129       };
53130     } catch (std::exception& e) {
53131       {
53132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53133       };
53134     } catch (Dali::DaliException e) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53137       };
53138     } catch (...) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53141       };
53142     }
53143   }
53144
53145 }
53146
53147
53148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
53149   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53150   Dali::KeyEvent *arg2 = 0 ;
53151
53152   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53153   arg2 = (Dali::KeyEvent *)jarg2;
53154   if (!arg2) {
53155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
53156     return ;
53157   }
53158   {
53159     try {
53160       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
53161     } catch (std::out_of_range& e) {
53162       {
53163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53164       };
53165     } catch (std::exception& e) {
53166       {
53167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53168       };
53169     } catch (Dali::DaliException e) {
53170       {
53171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53172       };
53173     } catch (...) {
53174       {
53175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53176       };
53177     }
53178   }
53179
53180 }
53181
53182
53183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53184   void * jresult ;
53185   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53186
53187   {
53188     try {
53189       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53190     } catch (std::out_of_range& e) {
53191       {
53192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53193       };
53194     } catch (std::exception& e) {
53195       {
53196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53197       };
53198     } catch (Dali::DaliException e) {
53199       {
53200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53201       };
53202     } catch (...) {
53203       {
53204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53205       };
53206     }
53207   }
53208
53209   jresult = (void *)result;
53210   return jresult;
53211 }
53212
53213
53214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53215   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53216
53217   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53218   {
53219     try {
53220       delete arg1;
53221     } catch (std::out_of_range& e) {
53222       {
53223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (std::exception& e) {
53226       {
53227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53228       };
53229     } catch (Dali::DaliException e) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53232       };
53233     } catch (...) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53236       };
53237     }
53238   }
53239
53240 }
53241
53242
53243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53244   unsigned int jresult ;
53245   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53246   bool result;
53247
53248   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53249   {
53250     try {
53251       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53252     } catch (std::out_of_range& e) {
53253       {
53254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53255       };
53256     } catch (std::exception& e) {
53257       {
53258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53259       };
53260     } catch (Dali::DaliException e) {
53261       {
53262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53263       };
53264     } catch (...) {
53265       {
53266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53267       };
53268     }
53269   }
53270
53271   jresult = result;
53272   return jresult;
53273 }
53274
53275
53276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53277   unsigned long jresult ;
53278   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53279   std::size_t result;
53280
53281   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53282   {
53283     try {
53284       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53285     } catch (std::out_of_range& e) {
53286       {
53287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53288       };
53289     } catch (std::exception& e) {
53290       {
53291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53292       };
53293     } catch (Dali::DaliException e) {
53294       {
53295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53296       };
53297     } catch (...) {
53298       {
53299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53300       };
53301     }
53302   }
53303
53304   jresult = (unsigned long)result;
53305   return jresult;
53306 }
53307
53308
53309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53310   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53311   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53312
53313   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53314   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53315   {
53316     try {
53317       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53318     } catch (std::out_of_range& e) {
53319       {
53320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53321       };
53322     } catch (std::exception& e) {
53323       {
53324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53325       };
53326     } catch (Dali::DaliException e) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53329       };
53330     } catch (...) {
53331       {
53332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53333       };
53334     }
53335   }
53336
53337 }
53338
53339
53340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53341   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53342   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53343
53344   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53345   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53346   {
53347     try {
53348       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53349     } catch (std::out_of_range& e) {
53350       {
53351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53352       };
53353     } catch (std::exception& e) {
53354       {
53355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53356       };
53357     } catch (Dali::DaliException e) {
53358       {
53359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53360       };
53361     } catch (...) {
53362       {
53363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53364       };
53365     }
53366   }
53367
53368 }
53369
53370
53371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53372   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53373   Dali::TouchEvent *arg2 = 0 ;
53374
53375   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53376   arg2 = (Dali::TouchEvent *)jarg2;
53377   if (!arg2) {
53378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53379     return ;
53380   }
53381   {
53382     try {
53383       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53384     } catch (std::out_of_range& e) {
53385       {
53386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53387       };
53388     } catch (std::exception& e) {
53389       {
53390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (Dali::DaliException e) {
53393       {
53394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53395       };
53396     } catch (...) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53399       };
53400     }
53401   }
53402
53403 }
53404
53405
53406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53407   void * jresult ;
53408   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53409
53410   {
53411     try {
53412       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53413     } catch (std::out_of_range& e) {
53414       {
53415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53416       };
53417     } catch (std::exception& e) {
53418       {
53419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53420       };
53421     } catch (Dali::DaliException e) {
53422       {
53423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53424       };
53425     } catch (...) {
53426       {
53427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53428       };
53429     }
53430   }
53431
53432   jresult = (void *)result;
53433   return jresult;
53434 }
53435
53436
53437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53438   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53439
53440   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53441   {
53442     try {
53443       delete arg1;
53444     } catch (std::out_of_range& e) {
53445       {
53446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53447       };
53448     } catch (std::exception& e) {
53449       {
53450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53451       };
53452     } catch (Dali::DaliException e) {
53453       {
53454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53455       };
53456     } catch (...) {
53457       {
53458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53459       };
53460     }
53461   }
53462
53463 }
53464
53465
53466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53467   unsigned int jresult ;
53468   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53469   bool result;
53470
53471   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53472   {
53473     try {
53474       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53475     } catch (std::out_of_range& e) {
53476       {
53477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53478       };
53479     } catch (std::exception& e) {
53480       {
53481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53482       };
53483     } catch (Dali::DaliException e) {
53484       {
53485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53486       };
53487     } catch (...) {
53488       {
53489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53490       };
53491     }
53492   }
53493
53494   jresult = result;
53495   return jresult;
53496 }
53497
53498
53499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53500   unsigned long jresult ;
53501   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53502   std::size_t result;
53503
53504   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53505   {
53506     try {
53507       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53508     } catch (std::out_of_range& e) {
53509       {
53510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53511       };
53512     } catch (std::exception& e) {
53513       {
53514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53515       };
53516     } catch (Dali::DaliException e) {
53517       {
53518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53519       };
53520     } catch (...) {
53521       {
53522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53523       };
53524     }
53525   }
53526
53527   jresult = (unsigned long)result;
53528   return jresult;
53529 }
53530
53531
53532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53533   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53534   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53535
53536   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53537   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53538   {
53539     try {
53540       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53541     } catch (std::out_of_range& e) {
53542       {
53543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53544       };
53545     } catch (std::exception& e) {
53546       {
53547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53548       };
53549     } catch (Dali::DaliException e) {
53550       {
53551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53552       };
53553     } catch (...) {
53554       {
53555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53556       };
53557     }
53558   }
53559
53560 }
53561
53562
53563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53564   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53565   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53566
53567   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53568   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53569   {
53570     try {
53571       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53572     } catch (std::out_of_range& e) {
53573       {
53574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53575       };
53576     } catch (std::exception& e) {
53577       {
53578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53579       };
53580     } catch (Dali::DaliException e) {
53581       {
53582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53583       };
53584     } catch (...) {
53585       {
53586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53587       };
53588     }
53589   }
53590
53591 }
53592
53593
53594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53595   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53596   Dali::WheelEvent *arg2 = 0 ;
53597
53598   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53599   arg2 = (Dali::WheelEvent *)jarg2;
53600   if (!arg2) {
53601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53602     return ;
53603   }
53604   {
53605     try {
53606       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53607     } catch (std::out_of_range& e) {
53608       {
53609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53610       };
53611     } catch (std::exception& e) {
53612       {
53613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53614       };
53615     } catch (Dali::DaliException e) {
53616       {
53617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53618       };
53619     } catch (...) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53622       };
53623     }
53624   }
53625
53626 }
53627
53628
53629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53630   void * jresult ;
53631   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53632
53633   {
53634     try {
53635       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53636     } catch (std::out_of_range& e) {
53637       {
53638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53639       };
53640     } catch (std::exception& e) {
53641       {
53642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53643       };
53644     } catch (Dali::DaliException e) {
53645       {
53646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53647       };
53648     } catch (...) {
53649       {
53650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53651       };
53652     }
53653   }
53654
53655   jresult = (void *)result;
53656   return jresult;
53657 }
53658
53659
53660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53661   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53662
53663   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53664   {
53665     try {
53666       delete arg1;
53667     } catch (std::out_of_range& e) {
53668       {
53669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53670       };
53671     } catch (std::exception& e) {
53672       {
53673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53674       };
53675     } catch (Dali::DaliException e) {
53676       {
53677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53678       };
53679     } catch (...) {
53680       {
53681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53682       };
53683     }
53684   }
53685
53686 }
53687
53688
53689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53690   void * jresult ;
53691   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53692
53693   {
53694     try {
53695       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53696     } catch (std::out_of_range& e) {
53697       {
53698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53699       };
53700     } catch (std::exception& e) {
53701       {
53702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53703       };
53704     } catch (Dali::DaliException e) {
53705       {
53706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53707       };
53708     } catch (...) {
53709       {
53710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53711       };
53712     }
53713   }
53714
53715   jresult = (void *)result;
53716   return jresult;
53717 }
53718
53719
53720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53721   void * jresult ;
53722   Dali::Radian arg1 ;
53723   Dali::Radian arg2 ;
53724   Dali::Radian *argp1 ;
53725   Dali::Radian *argp2 ;
53726   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53727
53728   argp1 = (Dali::Radian *)jarg1;
53729   if (!argp1) {
53730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53731     return 0;
53732   }
53733   arg1 = *argp1;
53734   argp2 = (Dali::Radian *)jarg2;
53735   if (!argp2) {
53736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53737     return 0;
53738   }
53739   arg2 = *argp2;
53740   {
53741     try {
53742       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53743     } catch (std::out_of_range& e) {
53744       {
53745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53746       };
53747     } catch (std::exception& e) {
53748       {
53749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53750       };
53751     } catch (Dali::DaliException e) {
53752       {
53753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53754       };
53755     } catch (...) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53758       };
53759     }
53760   }
53761
53762   jresult = (void *)result;
53763   return jresult;
53764 }
53765
53766
53767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53768   void * jresult ;
53769   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53770   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53771
53772   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53773   if (!arg1) {
53774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53775     return 0;
53776   }
53777   {
53778     try {
53779       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53780     } catch (std::out_of_range& e) {
53781       {
53782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (std::exception& e) {
53785       {
53786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53787       };
53788     } catch (Dali::DaliException e) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53795       };
53796     }
53797   }
53798
53799   jresult = (void *)result;
53800   return jresult;
53801 }
53802
53803
53804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53805   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53806   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53807
53808   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53809   arg2 = (Dali::Radian *)jarg2;
53810   if (arg1) (arg1)->first = *arg2;
53811 }
53812
53813
53814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53815   void * jresult ;
53816   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53817   Dali::Radian *result = 0 ;
53818
53819   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53820   result = (Dali::Radian *)& ((arg1)->first);
53821   jresult = (void *)result;
53822   return jresult;
53823 }
53824
53825
53826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53827   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53828   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53829
53830   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53831   arg2 = (Dali::Radian *)jarg2;
53832   if (arg1) (arg1)->second = *arg2;
53833 }
53834
53835
53836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53837   void * jresult ;
53838   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53839   Dali::Radian *result = 0 ;
53840
53841   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53842   result = (Dali::Radian *)& ((arg1)->second);
53843   jresult = (void *)result;
53844   return jresult;
53845 }
53846
53847
53848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53849   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53850
53851   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53852   {
53853     try {
53854       delete arg1;
53855     } catch (std::out_of_range& e) {
53856       {
53857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53858       };
53859     } catch (std::exception& e) {
53860       {
53861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53862       };
53863     } catch (Dali::DaliException e) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53866       };
53867     } catch (...) {
53868       {
53869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53870       };
53871     }
53872   }
53873
53874 }
53875
53876
53877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53878   unsigned int jresult ;
53879   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53880   bool result;
53881
53882   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53883   {
53884     try {
53885       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);
53886     } catch (std::out_of_range& e) {
53887       {
53888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53889       };
53890     } catch (std::exception& e) {
53891       {
53892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53893       };
53894     } catch (Dali::DaliException e) {
53895       {
53896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53897       };
53898     } catch (...) {
53899       {
53900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53901       };
53902     }
53903   }
53904
53905   jresult = result;
53906   return jresult;
53907 }
53908
53909
53910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53911   unsigned long jresult ;
53912   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53913   std::size_t result;
53914
53915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53916   {
53917     try {
53918       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);
53919     } catch (std::out_of_range& e) {
53920       {
53921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53922       };
53923     } catch (std::exception& e) {
53924       {
53925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53926       };
53927     } catch (Dali::DaliException e) {
53928       {
53929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53930       };
53931     } catch (...) {
53932       {
53933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53934       };
53935     }
53936   }
53937
53938   jresult = (unsigned long)result;
53939   return jresult;
53940 }
53941
53942
53943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53944   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53945   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53946
53947   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53948   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53949   {
53950     try {
53951       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53952     } catch (std::out_of_range& e) {
53953       {
53954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53955       };
53956     } catch (std::exception& e) {
53957       {
53958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53959       };
53960     } catch (Dali::DaliException e) {
53961       {
53962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53963       };
53964     } catch (...) {
53965       {
53966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53967       };
53968     }
53969   }
53970
53971 }
53972
53973
53974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53975   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53976   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53977
53978   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53979   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53980   {
53981     try {
53982       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53983     } catch (std::out_of_range& e) {
53984       {
53985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53986       };
53987     } catch (std::exception& e) {
53988       {
53989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53990       };
53991     } catch (Dali::DaliException e) {
53992       {
53993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53994       };
53995     } catch (...) {
53996       {
53997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53998       };
53999     }
54000   }
54001
54002 }
54003
54004
54005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54006   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54007   Dali::Actor arg2 ;
54008   Dali::PanGesture *arg3 = 0 ;
54009   Dali::Actor *argp2 ;
54010
54011   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54012   argp2 = (Dali::Actor *)jarg2;
54013   if (!argp2) {
54014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54015     return ;
54016   }
54017   arg2 = *argp2;
54018   arg3 = (Dali::PanGesture *)jarg3;
54019   if (!arg3) {
54020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
54021     return ;
54022   }
54023   {
54024     try {
54025       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54033       };
54034     } catch (Dali::DaliException e) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54037       };
54038     } catch (...) {
54039       {
54040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54041       };
54042     }
54043   }
54044
54045 }
54046
54047
54048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
54049   void * jresult ;
54050   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
54051
54052   {
54053     try {
54054       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
54055     } catch (std::out_of_range& e) {
54056       {
54057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54058       };
54059     } catch (std::exception& e) {
54060       {
54061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54062       };
54063     } catch (Dali::DaliException e) {
54064       {
54065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54066       };
54067     } catch (...) {
54068       {
54069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54070       };
54071     }
54072   }
54073
54074   jresult = (void *)result;
54075   return jresult;
54076 }
54077
54078
54079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
54080   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54081
54082   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54083   {
54084     try {
54085       delete arg1;
54086     } catch (std::out_of_range& e) {
54087       {
54088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54089       };
54090     } catch (std::exception& e) {
54091       {
54092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54093       };
54094     } catch (Dali::DaliException e) {
54095       {
54096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54097       };
54098     } catch (...) {
54099       {
54100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54101       };
54102     }
54103   }
54104
54105 }
54106
54107
54108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
54109   unsigned int jresult ;
54110   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54111   bool result;
54112
54113   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54114   {
54115     try {
54116       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);
54117     } catch (std::out_of_range& e) {
54118       {
54119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54120       };
54121     } catch (std::exception& e) {
54122       {
54123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54124       };
54125     } catch (Dali::DaliException e) {
54126       {
54127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54128       };
54129     } catch (...) {
54130       {
54131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54132       };
54133     }
54134   }
54135
54136   jresult = result;
54137   return jresult;
54138 }
54139
54140
54141 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54142   unsigned long jresult ;
54143   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54144   std::size_t result;
54145
54146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54147   {
54148     try {
54149       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);
54150     } catch (std::out_of_range& e) {
54151       {
54152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54153       };
54154     } catch (std::exception& e) {
54155       {
54156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54157       };
54158     } catch (Dali::DaliException e) {
54159       {
54160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54161       };
54162     } catch (...) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54165       };
54166     }
54167   }
54168
54169   jresult = (unsigned long)result;
54170   return jresult;
54171 }
54172
54173
54174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54175   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54176   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54177
54178   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54179   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54180   {
54181     try {
54182       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54183     } catch (std::out_of_range& e) {
54184       {
54185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54186       };
54187     } catch (std::exception& e) {
54188       {
54189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54190       };
54191     } catch (Dali::DaliException e) {
54192       {
54193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54194       };
54195     } catch (...) {
54196       {
54197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54198       };
54199     }
54200   }
54201
54202 }
54203
54204
54205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54206   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54207   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54208
54209   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54210   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54211   {
54212     try {
54213       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54214     } catch (std::out_of_range& e) {
54215       {
54216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54217       };
54218     } catch (std::exception& e) {
54219       {
54220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54221       };
54222     } catch (Dali::DaliException e) {
54223       {
54224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54225       };
54226     } catch (...) {
54227       {
54228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54229       };
54230     }
54231   }
54232
54233 }
54234
54235
54236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54237   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54238   Dali::Actor arg2 ;
54239   Dali::PinchGesture *arg3 = 0 ;
54240   Dali::Actor *argp2 ;
54241
54242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54243   argp2 = (Dali::Actor *)jarg2;
54244   if (!argp2) {
54245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54246     return ;
54247   }
54248   arg2 = *argp2;
54249   arg3 = (Dali::PinchGesture *)jarg3;
54250   if (!arg3) {
54251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54252     return ;
54253   }
54254   {
54255     try {
54256       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54257     } catch (std::out_of_range& e) {
54258       {
54259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54260       };
54261     } catch (std::exception& e) {
54262       {
54263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54264       };
54265     } catch (Dali::DaliException e) {
54266       {
54267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54268       };
54269     } catch (...) {
54270       {
54271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54272       };
54273     }
54274   }
54275
54276 }
54277
54278
54279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54280   void * jresult ;
54281   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54282
54283   {
54284     try {
54285       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54286     } catch (std::out_of_range& e) {
54287       {
54288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54289       };
54290     } catch (std::exception& e) {
54291       {
54292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54293       };
54294     } catch (Dali::DaliException e) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54297       };
54298     } catch (...) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54301       };
54302     }
54303   }
54304
54305   jresult = (void *)result;
54306   return jresult;
54307 }
54308
54309
54310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54311   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54312
54313   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54314   {
54315     try {
54316       delete arg1;
54317     } catch (std::out_of_range& e) {
54318       {
54319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54320       };
54321     } catch (std::exception& e) {
54322       {
54323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54324       };
54325     } catch (Dali::DaliException e) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54332       };
54333     }
54334   }
54335
54336 }
54337
54338
54339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54340   unsigned int jresult ;
54341   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54342   bool result;
54343
54344   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54345   {
54346     try {
54347       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);
54348     } catch (std::out_of_range& e) {
54349       {
54350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54351       };
54352     } catch (std::exception& e) {
54353       {
54354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54355       };
54356     } catch (Dali::DaliException e) {
54357       {
54358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54359       };
54360     } catch (...) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54363       };
54364     }
54365   }
54366
54367   jresult = result;
54368   return jresult;
54369 }
54370
54371
54372 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54373   unsigned long jresult ;
54374   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54375   std::size_t result;
54376
54377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54378   {
54379     try {
54380       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);
54381     } catch (std::out_of_range& e) {
54382       {
54383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54384       };
54385     } catch (std::exception& e) {
54386       {
54387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54388       };
54389     } catch (Dali::DaliException e) {
54390       {
54391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54392       };
54393     } catch (...) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54396       };
54397     }
54398   }
54399
54400   jresult = (unsigned long)result;
54401   return jresult;
54402 }
54403
54404
54405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54406   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54407   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54408
54409   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54410   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54411   {
54412     try {
54413       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54414     } catch (std::out_of_range& e) {
54415       {
54416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54417       };
54418     } catch (std::exception& e) {
54419       {
54420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54421       };
54422     } catch (Dali::DaliException e) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54425       };
54426     } catch (...) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54429       };
54430     }
54431   }
54432
54433 }
54434
54435
54436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54437   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54438   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54439
54440   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54441   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54442   {
54443     try {
54444       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54445     } catch (std::out_of_range& e) {
54446       {
54447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (std::exception& e) {
54450       {
54451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54452       };
54453     } catch (Dali::DaliException e) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54456       };
54457     } catch (...) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54460       };
54461     }
54462   }
54463
54464 }
54465
54466
54467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54468   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54469   Dali::Actor arg2 ;
54470   Dali::TapGesture *arg3 = 0 ;
54471   Dali::Actor *argp2 ;
54472
54473   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54474   argp2 = (Dali::Actor *)jarg2;
54475   if (!argp2) {
54476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54477     return ;
54478   }
54479   arg2 = *argp2;
54480   arg3 = (Dali::TapGesture *)jarg3;
54481   if (!arg3) {
54482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54483     return ;
54484   }
54485   {
54486     try {
54487       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54495       };
54496     } catch (Dali::DaliException e) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54499       };
54500     } catch (...) {
54501       {
54502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54503       };
54504     }
54505   }
54506
54507 }
54508
54509
54510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54511   void * jresult ;
54512   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54513
54514   {
54515     try {
54516       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (Dali::DaliException e) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54528       };
54529     } catch (...) {
54530       {
54531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54532       };
54533     }
54534   }
54535
54536   jresult = (void *)result;
54537   return jresult;
54538 }
54539
54540
54541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54542   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54543
54544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54545   {
54546     try {
54547       delete arg1;
54548     } catch (std::out_of_range& e) {
54549       {
54550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54551       };
54552     } catch (std::exception& e) {
54553       {
54554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54555       };
54556     } catch (Dali::DaliException e) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54563       };
54564     }
54565   }
54566
54567 }
54568
54569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54570   unsigned int jresult ;
54571   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54572   bool result = false;
54573
54574   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54575   {
54576     try {
54577       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);
54578     } catch (std::out_of_range& e) {
54579       {
54580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54581       };
54582     } catch (std::exception& e) {
54583       {
54584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54585       };
54586     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54587   }
54588   jresult = result;
54589   return jresult;
54590 }
54591
54592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54593   unsigned long jresult ;
54594   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54595   std::size_t result = 0;
54596
54597   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54598   {
54599     try {
54600       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);
54601     } catch (std::out_of_range& e) {
54602       {
54603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54604       };
54605     } catch (std::exception& e) {
54606       {
54607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54608       };
54609     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54610   }
54611   jresult = (unsigned long)result;
54612   return jresult;
54613 }
54614
54615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54616   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54617   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54618
54619   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54620   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54621   {
54622     try {
54623       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54624     } catch (std::out_of_range& e) {
54625       {
54626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54627       };
54628     } catch (std::exception& e) {
54629       {
54630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54631       };
54632     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54633   }
54634 }
54635
54636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54637   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54638   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54639
54640   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54641   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54642   {
54643     try {
54644       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54645     } catch (std::out_of_range& e) {
54646       {
54647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54648       };
54649     } catch (std::exception& e) {
54650       {
54651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54652       };
54653     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54654   }
54655 }
54656
54657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54658   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54659   Dali::Actor arg2 ;
54660   //bool arg3 ;
54661   Dali::LayoutDirection::Type arg4 ;
54662   Dali::Actor *argp2 ;
54663
54664   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54665   argp2 = (Dali::Actor *)jarg2;
54666   if (!argp2) {
54667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54668     return ;
54669   }
54670   arg2 = *argp2;
54671   //arg3 = jarg3 ? true : false;
54672   arg4 = (Dali::LayoutDirection::Type)jarg4;
54673   {
54674     try {
54675       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54676     } catch (std::out_of_range& e) {
54677       {
54678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54679       };
54680     } catch (std::exception& e) {
54681       {
54682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54683       };
54684     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54685   }
54686 }
54687
54688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54689   void * jresult ;
54690   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54691
54692   {
54693     try {
54694       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54695     } catch (std::out_of_range& e) {
54696       {
54697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54698       };
54699     } catch (std::exception& e) {
54700       {
54701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54702       };
54703     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54704   }
54705   jresult = (void *)result;
54706   return jresult;
54707 }
54708
54709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54710   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54711
54712   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54713   {
54714     try {
54715       delete arg1;
54716     } catch (std::out_of_range& e) {
54717       {
54718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54719       };
54720     } catch (std::exception& e) {
54721       {
54722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54723       };
54724     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54725   }
54726 }
54727
54728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54729   unsigned int jresult ;
54730   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54731   bool result;
54732
54733   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54734   {
54735     try {
54736       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);
54737     } catch (std::out_of_range& e) {
54738       {
54739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54740       };
54741     } catch (std::exception& e) {
54742       {
54743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54744       };
54745     } catch (Dali::DaliException e) {
54746       {
54747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54748       };
54749     } catch (...) {
54750       {
54751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54752       };
54753     }
54754   }
54755
54756   jresult = result;
54757   return jresult;
54758 }
54759
54760
54761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54762   unsigned long jresult ;
54763   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54764   std::size_t result;
54765
54766   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54767   {
54768     try {
54769       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);
54770     } catch (std::out_of_range& e) {
54771       {
54772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54773       };
54774     } catch (std::exception& e) {
54775       {
54776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54777       };
54778     } catch (Dali::DaliException e) {
54779       {
54780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54781       };
54782     } catch (...) {
54783       {
54784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54785       };
54786     }
54787   }
54788
54789   jresult = (unsigned long)result;
54790   return jresult;
54791 }
54792
54793
54794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54795   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54796   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54797
54798   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54799   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54800   {
54801     try {
54802       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54803     } catch (std::out_of_range& e) {
54804       {
54805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54806       };
54807     } catch (std::exception& e) {
54808       {
54809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54810       };
54811     } catch (Dali::DaliException e) {
54812       {
54813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54814       };
54815     } catch (...) {
54816       {
54817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54818       };
54819     }
54820   }
54821
54822 }
54823
54824
54825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54826   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54827   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54828
54829   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54830   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54831   {
54832     try {
54833       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54834     } catch (std::out_of_range& e) {
54835       {
54836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54837       };
54838     } catch (std::exception& e) {
54839       {
54840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54841       };
54842     } catch (Dali::DaliException e) {
54843       {
54844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54845       };
54846     } catch (...) {
54847       {
54848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54849       };
54850     }
54851   }
54852
54853 }
54854
54855
54856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54857   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54858   Dali::Actor arg2 ;
54859   bool arg3 ;
54860   Dali::DevelActor::VisibilityChange::Type arg4 ;
54861   Dali::Actor *argp2 ;
54862
54863   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54864   argp2 = (Dali::Actor *)jarg2;
54865   if (!argp2) {
54866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54867     return ;
54868   }
54869   arg2 = *argp2;
54870   arg3 = jarg3 ? true : false;
54871   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54872   {
54873     try {
54874       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54875     } catch (std::out_of_range& e) {
54876       {
54877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54878       };
54879     } catch (std::exception& e) {
54880       {
54881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54882       };
54883     } catch (Dali::DaliException e) {
54884       {
54885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54886       };
54887     } catch (...) {
54888       {
54889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54890       };
54891     }
54892   }
54893
54894 }
54895
54896
54897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54898   void * jresult ;
54899   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54900
54901   {
54902     try {
54903       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54904     } catch (std::out_of_range& e) {
54905       {
54906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54907       };
54908     } catch (std::exception& e) {
54909       {
54910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54911       };
54912     } catch (Dali::DaliException e) {
54913       {
54914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54915       };
54916     } catch (...) {
54917       {
54918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54919       };
54920     }
54921   }
54922
54923   jresult = (void *)result;
54924   return jresult;
54925 }
54926
54927
54928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54929   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54930
54931   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54932   {
54933     try {
54934       delete arg1;
54935     } catch (std::out_of_range& e) {
54936       {
54937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54938       };
54939     } catch (std::exception& e) {
54940       {
54941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54942       };
54943     } catch (Dali::DaliException e) {
54944       {
54945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54946       };
54947     } catch (...) {
54948       {
54949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54950       };
54951     }
54952   }
54953
54954 }
54955
54956
54957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54958   void * jresult ;
54959   Dali::Timer *result = 0 ;
54960
54961   {
54962     try {
54963       result = (Dali::Timer *)new Dali::Timer();
54964     } catch (std::out_of_range& e) {
54965       {
54966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54967       };
54968     } catch (std::exception& e) {
54969       {
54970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54971       };
54972     } catch (Dali::DaliException e) {
54973       {
54974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54975       };
54976     } catch (...) {
54977       {
54978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54979       };
54980     }
54981   }
54982
54983   jresult = (void *)result;
54984   return jresult;
54985 }
54986
54987
54988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54989   void * jresult ;
54990   unsigned int arg1 ;
54991   Dali::Timer result;
54992
54993   arg1 = (unsigned int)jarg1;
54994   {
54995     try {
54996       result = Dali::Timer::New(arg1);
54997     } catch (std::out_of_range& e) {
54998       {
54999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55000       };
55001     } catch (std::exception& e) {
55002       {
55003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55004       };
55005     } catch (Dali::DaliException e) {
55006       {
55007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55008       };
55009     } catch (...) {
55010       {
55011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55012       };
55013     }
55014   }
55015
55016   jresult = new Dali::Timer((const Dali::Timer &)result);
55017   return jresult;
55018 }
55019
55020
55021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
55022   void * jresult ;
55023   Dali::Timer *arg1 = 0 ;
55024   Dali::Timer *result = 0 ;
55025
55026   arg1 = (Dali::Timer *)jarg1;
55027   if (!arg1) {
55028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55029     return 0;
55030   }
55031   {
55032     try {
55033       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55041       };
55042     } catch (Dali::DaliException e) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55045       };
55046     } catch (...) {
55047       {
55048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55049       };
55050     }
55051   }
55052
55053   jresult = (void *)result;
55054   return jresult;
55055 }
55056
55057
55058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
55059   void * jresult ;
55060   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55061   Dali::Timer *arg2 = 0 ;
55062   Dali::Timer *result = 0 ;
55063
55064   arg1 = (Dali::Timer *)jarg1;
55065   arg2 = (Dali::Timer *)jarg2;
55066   if (!arg2) {
55067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55068     return 0;
55069   }
55070   {
55071     try {
55072       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
55073     } catch (std::out_of_range& e) {
55074       {
55075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (std::exception& e) {
55078       {
55079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (Dali::DaliException e) {
55082       {
55083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55088       };
55089     }
55090   }
55091
55092   jresult = (void *)result;
55093   return jresult;
55094 }
55095
55096
55097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
55098   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55099
55100   arg1 = (Dali::Timer *)jarg1;
55101   {
55102     try {
55103       delete arg1;
55104     } catch (std::out_of_range& e) {
55105       {
55106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55107       };
55108     } catch (std::exception& e) {
55109       {
55110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55111       };
55112     } catch (Dali::DaliException e) {
55113       {
55114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55115       };
55116     } catch (...) {
55117       {
55118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55119       };
55120     }
55121   }
55122
55123 }
55124
55125
55126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
55127   void * jresult ;
55128   Dali::BaseHandle arg1 ;
55129   Dali::BaseHandle *argp1 ;
55130   Dali::Timer result;
55131
55132   argp1 = (Dali::BaseHandle *)jarg1;
55133   if (!argp1) {
55134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
55135     return 0;
55136   }
55137   arg1 = *argp1;
55138   {
55139     try {
55140       result = Dali::Timer::DownCast(arg1);
55141     } catch (std::out_of_range& e) {
55142       {
55143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55144       };
55145     } catch (std::exception& e) {
55146       {
55147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55148       };
55149     } catch (Dali::DaliException e) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55152       };
55153     } catch (...) {
55154       {
55155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55156       };
55157     }
55158   }
55159
55160   jresult = new Dali::Timer((const Dali::Timer &)result);
55161   return jresult;
55162 }
55163
55164
55165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
55166   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55167
55168   arg1 = (Dali::Timer *)jarg1;
55169   {
55170     try {
55171       (arg1)->Start();
55172     } catch (std::out_of_range& e) {
55173       {
55174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55175       };
55176     } catch (std::exception& e) {
55177       {
55178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55179       };
55180     } catch (Dali::DaliException e) {
55181       {
55182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55183       };
55184     } catch (...) {
55185       {
55186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55187       };
55188     }
55189   }
55190
55191 }
55192
55193
55194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
55195   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55196
55197   arg1 = (Dali::Timer *)jarg1;
55198   {
55199     try {
55200       (arg1)->Stop();
55201     } catch (std::out_of_range& e) {
55202       {
55203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55204       };
55205     } catch (std::exception& e) {
55206       {
55207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55208       };
55209     } catch (Dali::DaliException e) {
55210       {
55211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55212       };
55213     } catch (...) {
55214       {
55215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55216       };
55217     }
55218   }
55219
55220 }
55221
55222
55223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55224   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55225   unsigned int arg2 ;
55226
55227   arg1 = (Dali::Timer *)jarg1;
55228   arg2 = (unsigned int)jarg2;
55229   {
55230     try {
55231       (arg1)->SetInterval(arg2);
55232     } catch (std::out_of_range& e) {
55233       {
55234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55235       };
55236     } catch (std::exception& e) {
55237       {
55238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55239       };
55240     } catch (Dali::DaliException e) {
55241       {
55242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55243       };
55244     } catch (...) {
55245       {
55246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55247       };
55248     }
55249   }
55250
55251 }
55252
55253
55254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55255   unsigned int jresult ;
55256   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55257   unsigned int result;
55258
55259   arg1 = (Dali::Timer *)jarg1;
55260   {
55261     try {
55262       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55263     } catch (std::out_of_range& e) {
55264       {
55265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55266       };
55267     } catch (std::exception& e) {
55268       {
55269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55270       };
55271     } catch (Dali::DaliException e) {
55272       {
55273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55274       };
55275     } catch (...) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55278       };
55279     }
55280   }
55281
55282   jresult = result;
55283   return jresult;
55284 }
55285
55286
55287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55288   unsigned int jresult ;
55289   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55290   bool result;
55291
55292   arg1 = (Dali::Timer *)jarg1;
55293   {
55294     try {
55295       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55296     } catch (std::out_of_range& e) {
55297       {
55298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55299       };
55300     } catch (std::exception& e) {
55301       {
55302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (Dali::DaliException e) {
55305       {
55306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55307       };
55308     } catch (...) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55311       };
55312     }
55313   }
55314
55315   jresult = result;
55316   return jresult;
55317 }
55318
55319
55320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55321   void * jresult ;
55322   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55323   Dali::Timer::TimerSignalType *result = 0 ;
55324
55325   arg1 = (Dali::Timer *)jarg1;
55326   {
55327     try {
55328       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55329     } catch (std::out_of_range& e) {
55330       {
55331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55332       };
55333     } catch (std::exception& e) {
55334       {
55335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55336       };
55337     } catch (Dali::DaliException e) {
55338       {
55339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55340       };
55341     } catch (...) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55344       };
55345     }
55346   }
55347
55348   jresult = (void *)result;
55349   return jresult;
55350 }
55351
55352
55353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55354   unsigned int jresult ;
55355   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55356   bool result;
55357
55358   arg1 = (Dali::Signal< bool () > *)jarg1;
55359   {
55360     try {
55361       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55369       };
55370     } catch (Dali::DaliException e) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55373       };
55374     } catch (...) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55377       };
55378     }
55379   }
55380
55381   jresult = result;
55382   return jresult;
55383 }
55384
55385
55386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55387   unsigned long jresult ;
55388   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55389   std::size_t result;
55390
55391   arg1 = (Dali::Signal< bool () > *)jarg1;
55392   {
55393     try {
55394       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55395     } catch (std::out_of_range& e) {
55396       {
55397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55398       };
55399     } catch (std::exception& e) {
55400       {
55401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55402       };
55403     } catch (Dali::DaliException e) {
55404       {
55405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55406       };
55407     } catch (...) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55410       };
55411     }
55412   }
55413
55414   jresult = (unsigned long)result;
55415   return jresult;
55416 }
55417
55418
55419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55420   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55421   bool (*arg2)() = (bool (*)()) 0 ;
55422
55423   arg1 = (Dali::Signal< bool () > *)jarg1;
55424   arg2 = (bool (*)())jarg2;
55425   {
55426     try {
55427       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55428     } catch (std::out_of_range& e) {
55429       {
55430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55431       };
55432     } catch (std::exception& e) {
55433       {
55434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55435       };
55436     } catch (Dali::DaliException e) {
55437       {
55438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55439       };
55440     } catch (...) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55443       };
55444     }
55445   }
55446
55447 }
55448
55449
55450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55451   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55452   bool (*arg2)() = (bool (*)()) 0 ;
55453
55454   arg1 = (Dali::Signal< bool () > *)jarg1;
55455   arg2 = (bool (*)())jarg2;
55456   {
55457     try {
55458       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55459     } catch (std::out_of_range& e) {
55460       {
55461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55462       };
55463     } catch (std::exception& e) {
55464       {
55465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55466       };
55467     } catch (Dali::DaliException e) {
55468       {
55469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55470       };
55471     } catch (...) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55474       };
55475     }
55476   }
55477
55478 }
55479
55480
55481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55482   unsigned int jresult ;
55483   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55484   bool result;
55485
55486   arg1 = (Dali::Signal< bool () > *)jarg1;
55487   {
55488     try {
55489       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55490     } catch (std::out_of_range& e) {
55491       {
55492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55493       };
55494     } catch (std::exception& e) {
55495       {
55496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55497       };
55498     } catch (Dali::DaliException e) {
55499       {
55500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55505       };
55506     }
55507   }
55508
55509   jresult = result;
55510   return jresult;
55511 }
55512
55513
55514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55515   void * jresult ;
55516   Dali::Signal< bool () > *result = 0 ;
55517
55518   {
55519     try {
55520       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55521     } catch (std::out_of_range& e) {
55522       {
55523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55524       };
55525     } catch (std::exception& e) {
55526       {
55527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55528       };
55529     } catch (Dali::DaliException e) {
55530       {
55531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55532       };
55533     } catch (...) {
55534       {
55535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55536       };
55537     }
55538   }
55539
55540   jresult = (void *)result;
55541   return jresult;
55542 }
55543
55544
55545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55546   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55547
55548   arg1 = (Dali::Signal< bool () > *)jarg1;
55549   {
55550     try {
55551       delete arg1;
55552     } catch (std::out_of_range& e) {
55553       {
55554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55555       };
55556     } catch (std::exception& e) {
55557       {
55558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55559       };
55560     } catch (Dali::DaliException e) {
55561       {
55562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55563       };
55564     } catch (...) {
55565       {
55566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55567       };
55568     }
55569   }
55570
55571 }
55572
55573
55574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55575   int jresult ;
55576   int result;
55577
55578   {
55579     try {
55580       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55581     } catch (std::out_of_range& e) {
55582       {
55583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (std::exception& e) {
55586       {
55587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (Dali::DaliException e) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55592       };
55593     } catch (...) {
55594       {
55595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55596       };
55597     }
55598   }
55599
55600   jresult = (int)result;
55601   return jresult;
55602 }
55603
55604
55605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55606   int jresult ;
55607   int result;
55608
55609   {
55610     try {
55611       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55612     } catch (std::out_of_range& e) {
55613       {
55614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55615       };
55616     } catch (std::exception& e) {
55617       {
55618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55619       };
55620     } catch (Dali::DaliException e) {
55621       {
55622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55623       };
55624     } catch (...) {
55625       {
55626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55627       };
55628     }
55629   }
55630
55631   jresult = (int)result;
55632   return jresult;
55633 }
55634
55635
55636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55637   int jresult ;
55638   int result;
55639
55640   {
55641     try {
55642       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55643     } catch (std::out_of_range& e) {
55644       {
55645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55646       };
55647     } catch (std::exception& e) {
55648       {
55649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55650       };
55651     } catch (Dali::DaliException e) {
55652       {
55653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55654       };
55655     } catch (...) {
55656       {
55657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55658       };
55659     }
55660   }
55661
55662   jresult = (int)result;
55663   return jresult;
55664 }
55665
55666
55667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55668   int jresult ;
55669   int result;
55670
55671   {
55672     try {
55673       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55674     } catch (std::out_of_range& e) {
55675       {
55676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55677       };
55678     } catch (std::exception& e) {
55679       {
55680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55681       };
55682     } catch (Dali::DaliException e) {
55683       {
55684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55685       };
55686     } catch (...) {
55687       {
55688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55689       };
55690     }
55691   }
55692
55693   jresult = (int)result;
55694   return jresult;
55695 }
55696
55697
55698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55699   int jresult ;
55700   int result;
55701
55702   {
55703     try {
55704       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55705     } catch (std::out_of_range& e) {
55706       {
55707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55708       };
55709     } catch (std::exception& e) {
55710       {
55711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (Dali::DaliException e) {
55714       {
55715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55720       };
55721     }
55722   }
55723
55724   jresult = (int)result;
55725   return jresult;
55726 }
55727
55728
55729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55730   int jresult ;
55731   int result;
55732
55733   {
55734     try {
55735       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (Dali::DaliException e) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55751       };
55752     }
55753   }
55754
55755   jresult = (int)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55761   int jresult ;
55762   int result;
55763
55764   {
55765     try {
55766       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (Dali::DaliException e) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55778       };
55779     } catch (...) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55782       };
55783     }
55784   }
55785
55786   jresult = (int)result;
55787   return jresult;
55788 }
55789
55790
55791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55792   int jresult ;
55793   int result;
55794
55795   {
55796     try {
55797       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55798     } catch (std::out_of_range& e) {
55799       {
55800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55801       };
55802     } catch (std::exception& e) {
55803       {
55804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55805       };
55806     } catch (Dali::DaliException e) {
55807       {
55808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55809       };
55810     } catch (...) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55813       };
55814     }
55815   }
55816
55817   jresult = (int)result;
55818   return jresult;
55819 }
55820
55821
55822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55823   int jresult ;
55824   int result;
55825
55826   {
55827     try {
55828       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55829     } catch (std::out_of_range& e) {
55830       {
55831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55832       };
55833     } catch (std::exception& e) {
55834       {
55835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (Dali::DaliException e) {
55838       {
55839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55840       };
55841     } catch (...) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55844       };
55845     }
55846   }
55847
55848   jresult = (int)result;
55849   return jresult;
55850 }
55851
55852
55853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55854   int jresult ;
55855   int result;
55856
55857   {
55858     try {
55859       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55867       };
55868     } catch (Dali::DaliException e) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55871       };
55872     } catch (...) {
55873       {
55874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55875       };
55876     }
55877   }
55878
55879   jresult = (int)result;
55880   return jresult;
55881 }
55882
55883
55884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55885   int jresult ;
55886   int result;
55887
55888   {
55889     try {
55890       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55891     } catch (std::out_of_range& e) {
55892       {
55893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55894       };
55895     } catch (std::exception& e) {
55896       {
55897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55898       };
55899     } catch (Dali::DaliException e) {
55900       {
55901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55902       };
55903     } catch (...) {
55904       {
55905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55906       };
55907     }
55908   }
55909
55910   jresult = (int)result;
55911   return jresult;
55912 }
55913
55914
55915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55916   int jresult ;
55917   int result;
55918
55919   {
55920     try {
55921       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55922     } catch (std::out_of_range& e) {
55923       {
55924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55925       };
55926     } catch (std::exception& e) {
55927       {
55928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55929       };
55930     } catch (Dali::DaliException e) {
55931       {
55932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55933       };
55934     } catch (...) {
55935       {
55936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55937       };
55938     }
55939   }
55940
55941   jresult = (int)result;
55942   return jresult;
55943 }
55944
55945
55946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55947   int jresult ;
55948   int result;
55949
55950   {
55951     try {
55952       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55953     } catch (std::out_of_range& e) {
55954       {
55955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55956       };
55957     } catch (std::exception& e) {
55958       {
55959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55960       };
55961     } catch (Dali::DaliException e) {
55962       {
55963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55964       };
55965     } catch (...) {
55966       {
55967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55968       };
55969     }
55970   }
55971
55972   jresult = (int)result;
55973   return jresult;
55974 }
55975
55976
55977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55978   int jresult ;
55979   int result;
55980
55981   {
55982     try {
55983       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55984     } catch (std::out_of_range& e) {
55985       {
55986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55987       };
55988     } catch (std::exception& e) {
55989       {
55990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55991       };
55992     } catch (Dali::DaliException e) {
55993       {
55994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55995       };
55996     } catch (...) {
55997       {
55998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55999       };
56000     }
56001   }
56002
56003   jresult = (int)result;
56004   return jresult;
56005 }
56006
56007
56008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56009   int jresult ;
56010   int result;
56011
56012   {
56013     try {
56014       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56015     } catch (std::out_of_range& e) {
56016       {
56017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (std::exception& e) {
56020       {
56021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56022       };
56023     } catch (Dali::DaliException e) {
56024       {
56025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56026       };
56027     } catch (...) {
56028       {
56029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56030       };
56031     }
56032   }
56033
56034   jresult = (int)result;
56035   return jresult;
56036 }
56037
56038
56039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56040   int jresult ;
56041   int result;
56042
56043   {
56044     try {
56045       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56046     } catch (std::out_of_range& e) {
56047       {
56048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56049       };
56050     } catch (std::exception& e) {
56051       {
56052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56053       };
56054     } catch (Dali::DaliException e) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56061       };
56062     }
56063   }
56064
56065   jresult = (int)result;
56066   return jresult;
56067 }
56068
56069
56070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56071   int jresult ;
56072   int result;
56073
56074   {
56075     try {
56076       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56077     } catch (std::out_of_range& e) {
56078       {
56079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (std::exception& e) {
56082       {
56083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (Dali::DaliException e) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56088       };
56089     } catch (...) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56092       };
56093     }
56094   }
56095
56096   jresult = (int)result;
56097   return jresult;
56098 }
56099
56100
56101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56102   int jresult ;
56103   int result;
56104
56105   {
56106     try {
56107       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56108     } catch (std::out_of_range& e) {
56109       {
56110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56111       };
56112     } catch (std::exception& e) {
56113       {
56114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56115       };
56116     } catch (Dali::DaliException e) {
56117       {
56118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56119       };
56120     } catch (...) {
56121       {
56122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56123       };
56124     }
56125   }
56126
56127   jresult = (int)result;
56128   return jresult;
56129 }
56130
56131
56132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56133   int jresult ;
56134   int result;
56135
56136   {
56137     try {
56138       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56139     } catch (std::out_of_range& e) {
56140       {
56141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (std::exception& e) {
56144       {
56145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (Dali::DaliException e) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56150       };
56151     } catch (...) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56154       };
56155     }
56156   }
56157
56158   jresult = (int)result;
56159   return jresult;
56160 }
56161
56162
56163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56164   int jresult ;
56165   int result;
56166
56167   {
56168     try {
56169       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56170     } catch (std::out_of_range& e) {
56171       {
56172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56173       };
56174     } catch (std::exception& e) {
56175       {
56176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56177       };
56178     } catch (Dali::DaliException e) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56181       };
56182     } catch (...) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56185       };
56186     }
56187   }
56188
56189   jresult = (int)result;
56190   return jresult;
56191 }
56192
56193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
56194   int jresult ;
56195   int result;
56196
56197   {
56198     try {
56199       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
56200     } catch (std::out_of_range& e) {
56201       {
56202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56203       };
56204     } catch (std::exception& e) {
56205       {
56206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (Dali::DaliException e) {
56209       {
56210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56211       };
56212     } catch (...) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56215       };
56216     }
56217   }
56218
56219   jresult = (int)result;
56220   return jresult;
56221 }
56222
56223
56224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56225   int jresult ;
56226   int result;
56227   {
56228     try
56229     {
56230       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (Dali::DaliException e) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56242       };
56243     } catch (...) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56246       };
56247     }
56248   }
56249
56250   jresult = (int)result;
56251   return jresult;
56252 }
56253
56254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56255   int jresult ;
56256   int result;
56257   {
56258     try
56259     {
56260       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56261     } catch (std::out_of_range& e) {
56262       {
56263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (std::exception& e) {
56266       {
56267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (Dali::DaliException e) {
56270       {
56271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279
56280   jresult = (int)result;
56281   return jresult;
56282 }
56283
56284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56285   int jresult ;
56286   int result;
56287   {
56288     try
56289     {
56290       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56291     } catch (std::out_of_range& e) {
56292       {
56293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (std::exception& e) {
56296       {
56297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56298       };
56299     } catch (Dali::DaliException e) {
56300       {
56301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56302       };
56303     } catch (...) {
56304       {
56305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56306       };
56307     }
56308   }
56309
56310   jresult = (int)result;
56311   return jresult;
56312 }
56313
56314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56315   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56316 }
56317
56318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56319   int jresult ;
56320   int result;
56321   {
56322     try
56323     {
56324       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56325     } catch (std::out_of_range& e) {
56326       {
56327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56328       };
56329     } catch (std::exception& e) {
56330       {
56331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56332       };
56333     } catch (Dali::DaliException e) {
56334       {
56335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56336       };
56337     } catch (...) {
56338       {
56339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56340       };
56341     }
56342   }
56343
56344   jresult = (int)result;
56345   return jresult;
56346 }
56347
56348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56349   int jresult ;
56350   int result;
56351   {
56352     try
56353     {
56354       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56355     } catch (std::out_of_range& e) {
56356       {
56357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56358       };
56359     } catch (std::exception& e) {
56360       {
56361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56362       };
56363     } catch (Dali::DaliException e) {
56364       {
56365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56366       };
56367     } catch (...) {
56368       {
56369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56370       };
56371     }
56372   }
56373
56374   jresult = (int)result;
56375   return jresult;
56376 }
56377
56378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56379   int jresult ;
56380   int result;
56381
56382   {
56383     try {
56384       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56385     } catch (std::out_of_range& e) {
56386       {
56387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56388       };
56389     } catch (std::exception& e) {
56390       {
56391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56392       };
56393     } catch (Dali::DaliException e) {
56394       {
56395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56396       };
56397     } catch (...) {
56398       {
56399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56400       };
56401     }
56402   }
56403
56404   jresult = (int)result;
56405   return jresult;
56406 }
56407
56408
56409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56410   int jresult ;
56411   int result;
56412
56413   {
56414     try {
56415       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56416     } catch (std::out_of_range& e) {
56417       {
56418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56419       };
56420     } catch (std::exception& e) {
56421       {
56422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (Dali::DaliException e) {
56425       {
56426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56427       };
56428     } catch (...) {
56429       {
56430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56431       };
56432     }
56433   }
56434
56435   jresult = (int)result;
56436   return jresult;
56437 }
56438
56439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56440   int jresult ;
56441   int result;
56442   {
56443     try
56444     {
56445       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56446     } catch (std::out_of_range& e) {
56447       {
56448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56449       };
56450     } catch (std::exception& e) {
56451       {
56452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56453       };
56454     } catch (...) {
56455       {
56456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56457       };
56458     }
56459   }
56460   jresult = (int)result;
56461   return jresult;
56462 }
56463
56464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56465   int jresult ;
56466   int result;
56467   {
56468     try
56469     {
56470       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56471     } catch (std::out_of_range& e) {
56472       {
56473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (std::exception& e) {
56476       {
56477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56478       };
56479     } catch (...) {
56480       {
56481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56482       };
56483     }
56484   }
56485   jresult = (int)result;
56486   return jresult;
56487 }
56488
56489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56490   int jresult ;
56491   int result;
56492   {
56493     try
56494     {
56495       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56496     } catch (std::out_of_range& e) {
56497       {
56498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56499       };
56500     } catch (std::exception& e) {
56501       {
56502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56507       };
56508     }
56509   }
56510   jresult = (int)result;
56511   return jresult;
56512 }
56513
56514
56515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56516   int jresult ;
56517   int result;
56518   {
56519     try
56520     {
56521       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56522     } catch (std::out_of_range& e) {
56523       {
56524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56525       };
56526     } catch (std::exception& e) {
56527       {
56528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56529       };
56530     } catch (...) {
56531       {
56532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56533       };
56534     }
56535   }
56536   jresult = (int)result;
56537   return jresult;
56538 }
56539
56540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56541   int jresult ;
56542   int result;
56543   {
56544     try
56545     {
56546       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56547     } catch (std::out_of_range& e) {
56548       {
56549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (std::exception& e) {
56552       {
56553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56554       };
56555     } catch (...) {
56556       {
56557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56558       };
56559     }
56560   }
56561   jresult = (int)result;
56562   return jresult;
56563 }
56564
56565
56566
56567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56568   int jresult ;
56569   int result;
56570
56571   {
56572     try {
56573       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56574     } catch (std::out_of_range& e) {
56575       {
56576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56577       };
56578     } catch (std::exception& e) {
56579       {
56580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56581       };
56582     } catch (Dali::DaliException e) {
56583       {
56584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56585       };
56586     } catch (...) {
56587       {
56588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56589       };
56590     }
56591   }
56592
56593   jresult = (int)result;
56594   return jresult;
56595 }
56596
56597
56598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56599   int jresult ;
56600   int result;
56601
56602   {
56603     try {
56604       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56605     } catch (std::out_of_range& e) {
56606       {
56607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56608       };
56609     } catch (std::exception& e) {
56610       {
56611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56612       };
56613     } catch (Dali::DaliException e) {
56614       {
56615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56616       };
56617     } catch (...) {
56618       {
56619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56620       };
56621     }
56622   }
56623
56624   jresult = (int)result;
56625   return jresult;
56626 }
56627
56628
56629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56630   int jresult ;
56631   int result;
56632
56633   {
56634     try {
56635       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56636     } catch (std::out_of_range& e) {
56637       {
56638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56639       };
56640     } catch (std::exception& e) {
56641       {
56642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56643       };
56644     } catch (Dali::DaliException e) {
56645       {
56646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56647       };
56648     } catch (...) {
56649       {
56650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56651       };
56652     }
56653   }
56654
56655   jresult = (int)result;
56656   return jresult;
56657 }
56658
56659
56660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56661   int jresult ;
56662   int result;
56663
56664   {
56665     try {
56666       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56667     } catch (std::out_of_range& e) {
56668       {
56669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56670       };
56671     } catch (std::exception& e) {
56672       {
56673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56674       };
56675     } catch (Dali::DaliException e) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56678       };
56679     } catch (...) {
56680       {
56681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56682       };
56683     }
56684   }
56685
56686   jresult = (int)result;
56687   return jresult;
56688 }
56689
56690
56691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56692   int jresult ;
56693   int result;
56694
56695   {
56696     try {
56697       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56698     } catch (std::out_of_range& e) {
56699       {
56700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (std::exception& e) {
56703       {
56704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56705       };
56706     } catch (Dali::DaliException e) {
56707       {
56708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56709       };
56710     } catch (...) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56713       };
56714     }
56715   }
56716
56717   jresult = (int)result;
56718   return jresult;
56719 }
56720
56721
56722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56723   int jresult ;
56724   int result;
56725
56726   {
56727     try {
56728       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56729     } catch (std::out_of_range& e) {
56730       {
56731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56732       };
56733     } catch (std::exception& e) {
56734       {
56735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56736       };
56737     } catch (Dali::DaliException e) {
56738       {
56739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56740       };
56741     } catch (...) {
56742       {
56743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56744       };
56745     }
56746   }
56747
56748   jresult = (int)result;
56749   return jresult;
56750 }
56751
56752
56753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56754   int jresult ;
56755   int result;
56756
56757   {
56758     try {
56759       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56760     } catch (std::out_of_range& e) {
56761       {
56762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56763       };
56764     } catch (std::exception& e) {
56765       {
56766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56767       };
56768     } catch (Dali::DaliException e) {
56769       {
56770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56771       };
56772     } catch (...) {
56773       {
56774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56775       };
56776     }
56777   }
56778
56779   jresult = (int)result;
56780   return jresult;
56781 }
56782
56783 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56784   int jresult ;
56785   int result;
56786
56787   {
56788     try {
56789       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56790     } catch (std::out_of_range& e) {
56791       {
56792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56793       };
56794     } catch (std::exception& e) {
56795       {
56796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56797       };
56798     } catch (...) {
56799       {
56800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56801       };
56802     }
56803   }
56804   jresult = (int)result;
56805   return jresult;
56806 }
56807
56808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56809   int jresult ;
56810   int result;
56811
56812   {
56813     try {
56814       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56815     } catch (std::out_of_range& e) {
56816       {
56817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56818       };
56819     } catch (std::exception& e) {
56820       {
56821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56822       };
56823     } catch (Dali::DaliException e) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56826       };
56827     } catch (...) {
56828       {
56829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56830       };
56831     }
56832   }
56833
56834   jresult = (int)result;
56835   return jresult;
56836 }
56837
56838
56839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56840   int jresult ;
56841   int result;
56842
56843   {
56844     try {
56845       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56846     } catch (std::out_of_range& e) {
56847       {
56848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56849       };
56850     } catch (std::exception& e) {
56851       {
56852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (Dali::DaliException e) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56857       };
56858     } catch (...) {
56859       {
56860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56861       };
56862     }
56863   }
56864
56865   jresult = (int)result;
56866   return jresult;
56867 }
56868
56869
56870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56871   int jresult ;
56872   int result;
56873
56874   {
56875     try {
56876       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56877     } catch (std::out_of_range& e) {
56878       {
56879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56880       };
56881     } catch (std::exception& e) {
56882       {
56883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56884       };
56885     } catch (Dali::DaliException e) {
56886       {
56887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56888       };
56889     } catch (...) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56892       };
56893     }
56894   }
56895
56896   jresult = (int)result;
56897   return jresult;
56898 }
56899
56900
56901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56902   int jresult ;
56903   int result;
56904
56905   {
56906     try {
56907       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56908     } catch (std::out_of_range& e) {
56909       {
56910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56911       };
56912     } catch (std::exception& e) {
56913       {
56914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56915       };
56916     } catch (Dali::DaliException e) {
56917       {
56918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56919       };
56920     } catch (...) {
56921       {
56922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56923       };
56924     }
56925   }
56926
56927   jresult = (int)result;
56928   return jresult;
56929 }
56930
56931
56932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56933   int jresult ;
56934   int result;
56935
56936   {
56937     try {
56938       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56939     } catch (std::out_of_range& e) {
56940       {
56941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56942       };
56943     } catch (std::exception& e) {
56944       {
56945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56946       };
56947     } catch (Dali::DaliException e) {
56948       {
56949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56950       };
56951     } catch (...) {
56952       {
56953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56954       };
56955     }
56956   }
56957
56958   jresult = (int)result;
56959   return jresult;
56960 }
56961
56962
56963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56964   int jresult ;
56965   int result;
56966
56967   {
56968     try {
56969       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56970     } catch (std::out_of_range& e) {
56971       {
56972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56973       };
56974     } catch (std::exception& e) {
56975       {
56976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56977       };
56978     } catch (Dali::DaliException e) {
56979       {
56980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56981       };
56982     } catch (...) {
56983       {
56984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56985       };
56986     }
56987   }
56988
56989   jresult = (int)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56995   int jresult ;
56996   int result;
56997
56998   {
56999     try {
57000       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (Dali::DaliException e) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019
57020   jresult = (int)result;
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57026   int jresult ;
57027   int result;
57028
57029   {
57030     try {
57031       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57032     } catch (std::out_of_range& e) {
57033       {
57034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (std::exception& e) {
57037       {
57038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (Dali::DaliException e) {
57041       {
57042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57043       };
57044     } catch (...) {
57045       {
57046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57047       };
57048     }
57049   }
57050
57051   jresult = (int)result;
57052   return jresult;
57053 }
57054
57055
57056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57057   int jresult ;
57058   int result;
57059
57060   {
57061     try {
57062       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57063     } catch (std::out_of_range& e) {
57064       {
57065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57066       };
57067     } catch (std::exception& e) {
57068       {
57069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (Dali::DaliException e) {
57072       {
57073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57074       };
57075     } catch (...) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57078       };
57079     }
57080   }
57081
57082   jresult = (int)result;
57083   return jresult;
57084 }
57085
57086
57087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57088   int jresult ;
57089   int result;
57090
57091   {
57092     try {
57093       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57094     } catch (std::out_of_range& e) {
57095       {
57096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57097       };
57098     } catch (std::exception& e) {
57099       {
57100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57101       };
57102     } catch (Dali::DaliException e) {
57103       {
57104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57105       };
57106     } catch (...) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57109       };
57110     }
57111   }
57112
57113   jresult = (int)result;
57114   return jresult;
57115 }
57116
57117
57118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57119   int jresult ;
57120   int result;
57121
57122   {
57123     try {
57124       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57125     } catch (std::out_of_range& e) {
57126       {
57127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57128       };
57129     } catch (std::exception& e) {
57130       {
57131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57132       };
57133     } catch (Dali::DaliException e) {
57134       {
57135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57136       };
57137     } catch (...) {
57138       {
57139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57140       };
57141     }
57142   }
57143
57144   jresult = (int)result;
57145   return jresult;
57146 }
57147
57148
57149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57150   int jresult ;
57151   int result;
57152
57153   {
57154     try {
57155       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57156     } catch (std::out_of_range& e) {
57157       {
57158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57159       };
57160     } catch (std::exception& e) {
57161       {
57162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (Dali::DaliException e) {
57165       {
57166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57167       };
57168     } catch (...) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57171       };
57172     }
57173   }
57174
57175   jresult = (int)result;
57176   return jresult;
57177 }
57178
57179
57180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57181   int jresult ;
57182   int result;
57183
57184   {
57185     try {
57186       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57187     } catch (std::out_of_range& e) {
57188       {
57189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (std::exception& e) {
57192       {
57193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57194       };
57195     } catch (Dali::DaliException e) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57198       };
57199     } catch (...) {
57200       {
57201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57202       };
57203     }
57204   }
57205
57206   jresult = (int)result;
57207   return jresult;
57208 }
57209
57210
57211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57212   int jresult ;
57213   int result;
57214
57215   {
57216     try {
57217       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57218     } catch (std::out_of_range& e) {
57219       {
57220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57221       };
57222     } catch (std::exception& e) {
57223       {
57224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (Dali::DaliException e) {
57227       {
57228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57229       };
57230     } catch (...) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57233       };
57234     }
57235   }
57236
57237   jresult = (int)result;
57238   return jresult;
57239 }
57240
57241
57242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57243   int jresult ;
57244   int result;
57245
57246   {
57247     try {
57248       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57249     } catch (std::out_of_range& e) {
57250       {
57251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57252       };
57253     } catch (std::exception& e) {
57254       {
57255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57256       };
57257     } catch (Dali::DaliException e) {
57258       {
57259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57260       };
57261     } catch (...) {
57262       {
57263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57264       };
57265     }
57266   }
57267
57268   jresult = (int)result;
57269   return jresult;
57270 }
57271
57272
57273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57274   int jresult ;
57275   int result;
57276
57277   {
57278     try {
57279       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57280     } catch (std::out_of_range& e) {
57281       {
57282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57283       };
57284     } catch (std::exception& e) {
57285       {
57286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57287       };
57288     } catch (Dali::DaliException e) {
57289       {
57290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57291       };
57292     } catch (...) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57295       };
57296     }
57297   }
57298
57299   jresult = (int)result;
57300   return jresult;
57301 }
57302
57303
57304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57305   int jresult ;
57306   int result;
57307
57308   {
57309     try {
57310       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57311     } catch (std::out_of_range& e) {
57312       {
57313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57314       };
57315     } catch (std::exception& e) {
57316       {
57317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (Dali::DaliException e) {
57320       {
57321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57326       };
57327     }
57328   }
57329
57330   jresult = (int)result;
57331   return jresult;
57332 }
57333
57334
57335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57336   int jresult ;
57337   int result;
57338
57339   {
57340     try {
57341       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57342     } catch (std::out_of_range& e) {
57343       {
57344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57345       };
57346     } catch (std::exception& e) {
57347       {
57348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57349       };
57350     } catch (Dali::DaliException e) {
57351       {
57352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57353       };
57354     } catch (...) {
57355       {
57356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57357       };
57358     }
57359   }
57360
57361   jresult = (int)result;
57362   return jresult;
57363 }
57364
57365
57366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57367   int jresult ;
57368   int result;
57369
57370   {
57371     try {
57372       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57373     } catch (std::out_of_range& e) {
57374       {
57375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (std::exception& e) {
57378       {
57379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57380       };
57381     } catch (Dali::DaliException e) {
57382       {
57383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57384       };
57385     } catch (...) {
57386       {
57387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57388       };
57389     }
57390   }
57391
57392   jresult = (int)result;
57393   return jresult;
57394 }
57395
57396
57397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57398   int jresult ;
57399   int result;
57400
57401   {
57402     try {
57403       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57404     } catch (std::out_of_range& e) {
57405       {
57406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57407       };
57408     } catch (std::exception& e) {
57409       {
57410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (Dali::DaliException e) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57415       };
57416     } catch (...) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57419       };
57420     }
57421   }
57422
57423   jresult = (int)result;
57424   return jresult;
57425 }
57426
57427
57428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57429   int jresult ;
57430   int result;
57431
57432   {
57433     try {
57434       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57435     } catch (std::out_of_range& e) {
57436       {
57437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57438       };
57439     } catch (std::exception& e) {
57440       {
57441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57442       };
57443     } catch (Dali::DaliException e) {
57444       {
57445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57446       };
57447     } catch (...) {
57448       {
57449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57450       };
57451     }
57452   }
57453
57454   jresult = (int)result;
57455   return jresult;
57456 }
57457
57458
57459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57460   int jresult ;
57461   int result;
57462
57463   {
57464     try {
57465       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57466     } catch (std::out_of_range& e) {
57467       {
57468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57469       };
57470     } catch (std::exception& e) {
57471       {
57472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57473       };
57474     } catch (Dali::DaliException e) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57481       };
57482     }
57483   }
57484
57485   jresult = (int)result;
57486   return jresult;
57487 }
57488
57489
57490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57491   int jresult ;
57492   int result;
57493
57494   {
57495     try {
57496       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57497     } catch (std::out_of_range& e) {
57498       {
57499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57500       };
57501     } catch (std::exception& e) {
57502       {
57503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57504       };
57505     } catch (Dali::DaliException e) {
57506       {
57507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57508       };
57509     } catch (...) {
57510       {
57511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57512       };
57513     }
57514   }
57515
57516   jresult = (int)result;
57517   return jresult;
57518 }
57519
57520
57521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57522   int jresult ;
57523   int result;
57524
57525   {
57526     try {
57527       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57528     } catch (std::out_of_range& e) {
57529       {
57530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (std::exception& e) {
57533       {
57534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57535       };
57536     } catch (Dali::DaliException e) {
57537       {
57538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57539       };
57540     } catch (...) {
57541       {
57542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57543       };
57544     }
57545   }
57546
57547   jresult = (int)result;
57548   return jresult;
57549 }
57550
57551
57552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57553   int jresult ;
57554   int result;
57555
57556   {
57557     try {
57558       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57559     } catch (std::out_of_range& e) {
57560       {
57561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57562       };
57563     } catch (std::exception& e) {
57564       {
57565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57566       };
57567     } catch (Dali::DaliException e) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57570       };
57571     } catch (...) {
57572       {
57573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57574       };
57575     }
57576   }
57577
57578   jresult = (int)result;
57579   return jresult;
57580 }
57581
57582
57583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57584   int jresult ;
57585   int result;
57586
57587   {
57588     try {
57589       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57590     } catch (std::out_of_range& e) {
57591       {
57592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57593       };
57594     } catch (std::exception& e) {
57595       {
57596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57597       };
57598     } catch (Dali::DaliException e) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57601       };
57602     } catch (...) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57605       };
57606     }
57607   }
57608
57609   jresult = (int)result;
57610   return jresult;
57611 }
57612
57613
57614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57615   int jresult ;
57616   int result;
57617
57618   {
57619     try {
57620       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57621     } catch (std::out_of_range& e) {
57622       {
57623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57624       };
57625     } catch (std::exception& e) {
57626       {
57627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57628       };
57629     } catch (Dali::DaliException e) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57632       };
57633     } catch (...) {
57634       {
57635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57636       };
57637     }
57638   }
57639
57640   jresult = (int)result;
57641   return jresult;
57642 }
57643
57644
57645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57646   int jresult ;
57647   int result;
57648
57649   {
57650     try {
57651       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57652     } catch (std::out_of_range& e) {
57653       {
57654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57655       };
57656     } catch (std::exception& e) {
57657       {
57658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57659       };
57660     } catch (Dali::DaliException e) {
57661       {
57662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57663       };
57664     } catch (...) {
57665       {
57666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57667       };
57668     }
57669   }
57670
57671   jresult = (int)result;
57672   return jresult;
57673 }
57674
57675
57676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57677   void * jresult ;
57678   Dali::Toolkit::Builder *result = 0 ;
57679
57680   {
57681     try {
57682       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57683     } catch (std::out_of_range& e) {
57684       {
57685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57686       };
57687     } catch (std::exception& e) {
57688       {
57689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57690       };
57691     } catch (Dali::DaliException e) {
57692       {
57693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57694       };
57695     } catch (...) {
57696       {
57697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57698       };
57699     }
57700   }
57701
57702   jresult = (void *)result;
57703   return jresult;
57704 }
57705
57706
57707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57708   void * jresult ;
57709   Dali::Toolkit::Builder result;
57710
57711   {
57712     try {
57713       result = Dali::Toolkit::Builder::New();
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::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57734   return jresult;
57735 }
57736
57737
57738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57739   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57740
57741   arg1 = (Dali::Toolkit::Builder *)jarg1;
57742   {
57743     try {
57744       delete arg1;
57745     } catch (std::out_of_range& e) {
57746       {
57747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57748       };
57749     } catch (std::exception& e) {
57750       {
57751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57752       };
57753     } catch (Dali::DaliException e) {
57754       {
57755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57756       };
57757     } catch (...) {
57758       {
57759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57760       };
57761     }
57762   }
57763
57764 }
57765
57766
57767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57768   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57769   std::string *arg2 = 0 ;
57770   Dali::Toolkit::Builder::UIFormat arg3 ;
57771
57772   arg1 = (Dali::Toolkit::Builder *)jarg1;
57773   if (!jarg2) {
57774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57775     return ;
57776   }
57777   std::string arg2_str(jarg2);
57778   arg2 = &arg2_str;
57779   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57780   {
57781     try {
57782       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57790       };
57791     } catch (Dali::DaliException e) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57794       };
57795     } catch (...) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57798       };
57799     }
57800   }
57801
57802
57803   //argout typemap for const std::string&
57804
57805 }
57806
57807
57808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57810   std::string *arg2 = 0 ;
57811
57812   arg1 = (Dali::Toolkit::Builder *)jarg1;
57813   if (!jarg2) {
57814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57815     return ;
57816   }
57817   std::string arg2_str(jarg2);
57818   arg2 = &arg2_str;
57819   {
57820     try {
57821       (arg1)->LoadFromString((std::string const &)*arg2);
57822     } catch (std::out_of_range& e) {
57823       {
57824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57825       };
57826     } catch (std::exception& e) {
57827       {
57828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57829       };
57830     } catch (Dali::DaliException e) {
57831       {
57832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57833       };
57834     } catch (...) {
57835       {
57836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57837       };
57838     }
57839   }
57840
57841
57842   //argout typemap for const std::string&
57843
57844 }
57845
57846
57847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57848   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57849   Dali::Property::Map *arg2 = 0 ;
57850
57851   arg1 = (Dali::Toolkit::Builder *)jarg1;
57852   arg2 = (Dali::Property::Map *)jarg2;
57853   if (!arg2) {
57854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57855     return ;
57856   }
57857   {
57858     try {
57859       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57860     } catch (std::out_of_range& e) {
57861       {
57862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57863       };
57864     } catch (std::exception& e) {
57865       {
57866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57867       };
57868     } catch (Dali::DaliException e) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57871       };
57872     } catch (...) {
57873       {
57874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57875       };
57876     }
57877   }
57878
57879 }
57880
57881
57882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57883   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57884   std::string *arg2 = 0 ;
57885   Dali::Property::Value *arg3 = 0 ;
57886
57887   arg1 = (Dali::Toolkit::Builder *)jarg1;
57888   if (!jarg2) {
57889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57890     return ;
57891   }
57892   std::string arg2_str(jarg2);
57893   arg2 = &arg2_str;
57894   arg3 = (Dali::Property::Value *)jarg3;
57895   if (!arg3) {
57896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57897     return ;
57898   }
57899   {
57900     try {
57901       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57902     } catch (std::out_of_range& e) {
57903       {
57904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57905       };
57906     } catch (std::exception& e) {
57907       {
57908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57909       };
57910     } catch (Dali::DaliException e) {
57911       {
57912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57913       };
57914     } catch (...) {
57915       {
57916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57917       };
57918     }
57919   }
57920
57921
57922   //argout typemap for const std::string&
57923
57924 }
57925
57926
57927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57928   void * jresult ;
57929   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57930   Dali::Property::Map *result = 0 ;
57931
57932   arg1 = (Dali::Toolkit::Builder *)jarg1;
57933   {
57934     try {
57935       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57936     } catch (std::out_of_range& e) {
57937       {
57938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57939       };
57940     } catch (std::exception& e) {
57941       {
57942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (Dali::DaliException e) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57947       };
57948     } catch (...) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57951       };
57952     }
57953   }
57954
57955   jresult = (void *)result;
57956   return jresult;
57957 }
57958
57959
57960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57961   void * jresult ;
57962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57963   std::string *arg2 = 0 ;
57964   Dali::Property::Value *result = 0 ;
57965
57966   arg1 = (Dali::Toolkit::Builder *)jarg1;
57967   if (!jarg2) {
57968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57969     return 0;
57970   }
57971   std::string arg2_str(jarg2);
57972   arg2 = &arg2_str;
57973   {
57974     try {
57975       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57976     } catch (std::out_of_range& e) {
57977       {
57978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57979       };
57980     } catch (std::exception& e) {
57981       {
57982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57983       };
57984     } catch (Dali::DaliException e) {
57985       {
57986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57987       };
57988     } catch (...) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57991       };
57992     }
57993   }
57994
57995   jresult = (void *)result;
57996
57997   //argout typemap for const std::string&
57998
57999   return jresult;
58000 }
58001
58002
58003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58004   void * jresult ;
58005   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58006   std::string *arg2 = 0 ;
58007   Dali::Animation result;
58008
58009   arg1 = (Dali::Toolkit::Builder *)jarg1;
58010   if (!jarg2) {
58011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58012     return 0;
58013   }
58014   std::string arg2_str(jarg2);
58015   arg2 = &arg2_str;
58016   {
58017     try {
58018       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58019     } catch (std::out_of_range& e) {
58020       {
58021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58022       };
58023     } catch (std::exception& e) {
58024       {
58025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58026       };
58027     } catch (Dali::DaliException e) {
58028       {
58029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58030       };
58031     } catch (...) {
58032       {
58033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58034       };
58035     }
58036   }
58037
58038   jresult = new Dali::Animation((const Dali::Animation &)result);
58039
58040   //argout typemap for const std::string&
58041
58042   return jresult;
58043 }
58044
58045
58046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58047   void * jresult ;
58048   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58049   std::string *arg2 = 0 ;
58050   Dali::Property::Map *arg3 = 0 ;
58051   Dali::Animation result;
58052
58053   arg1 = (Dali::Toolkit::Builder *)jarg1;
58054   if (!jarg2) {
58055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58056     return 0;
58057   }
58058   std::string arg2_str(jarg2);
58059   arg2 = &arg2_str;
58060   arg3 = (Dali::Property::Map *)jarg3;
58061   if (!arg3) {
58062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58063     return 0;
58064   }
58065   {
58066     try {
58067       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58068     } catch (std::out_of_range& e) {
58069       {
58070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58071       };
58072     } catch (std::exception& e) {
58073       {
58074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58075       };
58076     } catch (Dali::DaliException e) {
58077       {
58078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58079       };
58080     } catch (...) {
58081       {
58082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58083       };
58084     }
58085   }
58086
58087   jresult = new Dali::Animation((const Dali::Animation &)result);
58088
58089   //argout typemap for const std::string&
58090
58091   return jresult;
58092 }
58093
58094
58095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58096   void * jresult ;
58097   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58098   std::string *arg2 = 0 ;
58099   Dali::Actor arg3 ;
58100   Dali::Actor *argp3 ;
58101   Dali::Animation result;
58102
58103   arg1 = (Dali::Toolkit::Builder *)jarg1;
58104   if (!jarg2) {
58105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58106     return 0;
58107   }
58108   std::string arg2_str(jarg2);
58109   arg2 = &arg2_str;
58110   argp3 = (Dali::Actor *)jarg3;
58111   if (!argp3) {
58112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58113     return 0;
58114   }
58115   arg3 = *argp3;
58116   {
58117     try {
58118       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58119     } catch (std::out_of_range& e) {
58120       {
58121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58122       };
58123     } catch (std::exception& e) {
58124       {
58125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58126       };
58127     } catch (Dali::DaliException e) {
58128       {
58129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58130       };
58131     } catch (...) {
58132       {
58133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58134       };
58135     }
58136   }
58137
58138   jresult = new Dali::Animation((const Dali::Animation &)result);
58139
58140   //argout typemap for const std::string&
58141
58142   return jresult;
58143 }
58144
58145
58146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58147   void * jresult ;
58148   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58149   std::string *arg2 = 0 ;
58150   Dali::Property::Map *arg3 = 0 ;
58151   Dali::Actor arg4 ;
58152   Dali::Actor *argp4 ;
58153   Dali::Animation result;
58154
58155   arg1 = (Dali::Toolkit::Builder *)jarg1;
58156   if (!jarg2) {
58157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58158     return 0;
58159   }
58160   std::string arg2_str(jarg2);
58161   arg2 = &arg2_str;
58162   arg3 = (Dali::Property::Map *)jarg3;
58163   if (!arg3) {
58164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58165     return 0;
58166   }
58167   argp4 = (Dali::Actor *)jarg4;
58168   if (!argp4) {
58169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58170     return 0;
58171   }
58172   arg4 = *argp4;
58173   {
58174     try {
58175       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58176     } catch (std::out_of_range& e) {
58177       {
58178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (std::exception& e) {
58181       {
58182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (Dali::DaliException e) {
58185       {
58186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58187       };
58188     } catch (...) {
58189       {
58190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58191       };
58192     }
58193   }
58194
58195   jresult = new Dali::Animation((const Dali::Animation &)result);
58196
58197   //argout typemap for const std::string&
58198
58199   return jresult;
58200 }
58201
58202
58203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58204   void * jresult ;
58205   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58206   std::string *arg2 = 0 ;
58207   Dali::BaseHandle result;
58208
58209   arg1 = (Dali::Toolkit::Builder *)jarg1;
58210   if (!jarg2) {
58211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58212     return 0;
58213   }
58214   std::string arg2_str(jarg2);
58215   arg2 = &arg2_str;
58216   {
58217     try {
58218       result = (arg1)->Create((std::string const &)*arg2);
58219     } catch (std::out_of_range& e) {
58220       {
58221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (std::exception& e) {
58224       {
58225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58226       };
58227     } catch (Dali::DaliException e) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58230       };
58231     } catch (...) {
58232       {
58233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58234       };
58235     }
58236   }
58237
58238   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58239
58240   //argout typemap for const std::string&
58241
58242   return jresult;
58243 }
58244
58245
58246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58247   void * jresult ;
58248   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58249   std::string *arg2 = 0 ;
58250   Dali::Property::Map *arg3 = 0 ;
58251   Dali::BaseHandle result;
58252
58253   arg1 = (Dali::Toolkit::Builder *)jarg1;
58254   if (!jarg2) {
58255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58256     return 0;
58257   }
58258   std::string arg2_str(jarg2);
58259   arg2 = &arg2_str;
58260   arg3 = (Dali::Property::Map *)jarg3;
58261   if (!arg3) {
58262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58263     return 0;
58264   }
58265   {
58266     try {
58267       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58268     } catch (std::out_of_range& e) {
58269       {
58270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58271       };
58272     } catch (std::exception& e) {
58273       {
58274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58275       };
58276     } catch (Dali::DaliException e) {
58277       {
58278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58279       };
58280     } catch (...) {
58281       {
58282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58283       };
58284     }
58285   }
58286
58287   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58288
58289   //argout typemap for const std::string&
58290
58291   return jresult;
58292 }
58293
58294
58295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58296   void * jresult ;
58297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58298   std::string *arg2 = 0 ;
58299   Dali::BaseHandle result;
58300
58301   arg1 = (Dali::Toolkit::Builder *)jarg1;
58302   if (!jarg2) {
58303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58304     return 0;
58305   }
58306   std::string arg2_str(jarg2);
58307   arg2 = &arg2_str;
58308   {
58309     try {
58310       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58311     } catch (std::out_of_range& e) {
58312       {
58313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (std::exception& e) {
58316       {
58317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58318       };
58319     } catch (Dali::DaliException e) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58322       };
58323     } catch (...) {
58324       {
58325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58326       };
58327     }
58328   }
58329
58330   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58331
58332   //argout typemap for const std::string&
58333
58334   return jresult;
58335 }
58336
58337
58338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58339   unsigned int jresult ;
58340   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58341   std::string *arg2 = 0 ;
58342   Dali::Handle *arg3 = 0 ;
58343   bool result;
58344
58345   arg1 = (Dali::Toolkit::Builder *)jarg1;
58346   if (!jarg2) {
58347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58348     return 0;
58349   }
58350   std::string arg2_str(jarg2);
58351   arg2 = &arg2_str;
58352   arg3 = (Dali::Handle *)jarg3;
58353   if (!arg3) {
58354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58355     return 0;
58356   }
58357   {
58358     try {
58359       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = result;
58380
58381   //argout typemap for const std::string&
58382
58383   return jresult;
58384 }
58385
58386
58387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58388   unsigned int jresult ;
58389   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58390   Dali::Handle *arg2 = 0 ;
58391   std::string *arg3 = 0 ;
58392   bool result;
58393
58394   arg1 = (Dali::Toolkit::Builder *)jarg1;
58395   arg2 = (Dali::Handle *)jarg2;
58396   if (!arg2) {
58397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58398     return 0;
58399   }
58400   if (!jarg3) {
58401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58402     return 0;
58403   }
58404   std::string arg3_str(jarg3);
58405   arg3 = &arg3_str;
58406   {
58407     try {
58408       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58409     } catch (std::out_of_range& e) {
58410       {
58411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58412       };
58413     } catch (std::exception& e) {
58414       {
58415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58416       };
58417     } catch (Dali::DaliException e) {
58418       {
58419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58420       };
58421     } catch (...) {
58422       {
58423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58424       };
58425     }
58426   }
58427
58428   jresult = result;
58429
58430   //argout typemap for const std::string&
58431
58432   return jresult;
58433 }
58434
58435
58436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58437   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58438   Dali::Actor arg2 ;
58439   Dali::Actor *argp2 ;
58440
58441   arg1 = (Dali::Toolkit::Builder *)jarg1;
58442   argp2 = (Dali::Actor *)jarg2;
58443   if (!argp2) {
58444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58445     return ;
58446   }
58447   arg2 = *argp2;
58448   {
58449     try {
58450       (arg1)->AddActors(arg2);
58451     } catch (std::out_of_range& e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58454       };
58455     } catch (std::exception& e) {
58456       {
58457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58458       };
58459     } catch (Dali::DaliException e) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58462       };
58463     } catch (...) {
58464       {
58465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58466       };
58467     }
58468   }
58469
58470 }
58471
58472
58473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58475   std::string *arg2 = 0 ;
58476   Dali::Actor arg3 ;
58477   Dali::Actor *argp3 ;
58478
58479   arg1 = (Dali::Toolkit::Builder *)jarg1;
58480   if (!jarg2) {
58481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58482     return ;
58483   }
58484   std::string arg2_str(jarg2);
58485   arg2 = &arg2_str;
58486   argp3 = (Dali::Actor *)jarg3;
58487   if (!argp3) {
58488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58489     return ;
58490   }
58491   arg3 = *argp3;
58492   {
58493     try {
58494       (arg1)->AddActors((std::string const &)*arg2,arg3);
58495     } catch (std::out_of_range& e) {
58496       {
58497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58498       };
58499     } catch (std::exception& e) {
58500       {
58501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58502       };
58503     } catch (Dali::DaliException e) {
58504       {
58505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58506       };
58507     } catch (...) {
58508       {
58509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58510       };
58511     }
58512   }
58513
58514
58515   //argout typemap for const std::string&
58516
58517 }
58518
58519
58520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58521   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58522   std::string *arg2 = 0 ;
58523
58524   arg1 = (Dali::Toolkit::Builder *)jarg1;
58525   if (!jarg2) {
58526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58527     return ;
58528   }
58529   std::string arg2_str(jarg2);
58530   arg2 = &arg2_str;
58531   {
58532     try {
58533       (arg1)->CreateRenderTask((std::string const &)*arg2);
58534     } catch (std::out_of_range& e) {
58535       {
58536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58537       };
58538     } catch (std::exception& e) {
58539       {
58540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58541       };
58542     } catch (Dali::DaliException e) {
58543       {
58544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58545       };
58546     } catch (...) {
58547       {
58548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58549       };
58550     }
58551   }
58552
58553
58554   //argout typemap for const std::string&
58555
58556 }
58557
58558
58559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58560   void * jresult ;
58561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58562   std::string *arg2 = 0 ;
58563   Dali::Path result;
58564
58565   arg1 = (Dali::Toolkit::Builder *)jarg1;
58566   if (!jarg2) {
58567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58568     return 0;
58569   }
58570   std::string arg2_str(jarg2);
58571   arg2 = &arg2_str;
58572   {
58573     try {
58574       result = (arg1)->GetPath((std::string const &)*arg2);
58575     } catch (std::out_of_range& e) {
58576       {
58577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58578       };
58579     } catch (std::exception& e) {
58580       {
58581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58582       };
58583     } catch (Dali::DaliException e) {
58584       {
58585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58586       };
58587     } catch (...) {
58588       {
58589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58590       };
58591     }
58592   }
58593
58594   jresult = new Dali::Path((const Dali::Path &)result);
58595
58596   //argout typemap for const std::string&
58597
58598   return jresult;
58599 }
58600
58601
58602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58603   void * jresult ;
58604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58605   std::string *arg2 = 0 ;
58606   Dali::PathConstrainer result;
58607
58608   arg1 = (Dali::Toolkit::Builder *)jarg1;
58609   if (!jarg2) {
58610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58611     return 0;
58612   }
58613   std::string arg2_str(jarg2);
58614   arg2 = &arg2_str;
58615   {
58616     try {
58617       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58618     } catch (std::out_of_range& e) {
58619       {
58620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58621       };
58622     } catch (std::exception& e) {
58623       {
58624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58625       };
58626     } catch (Dali::DaliException e) {
58627       {
58628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58629       };
58630     } catch (...) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58633       };
58634     }
58635   }
58636
58637   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58638
58639   //argout typemap for const std::string&
58640
58641   return jresult;
58642 }
58643
58644
58645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58646   void * jresult ;
58647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58648   std::string *arg2 = 0 ;
58649   Dali::LinearConstrainer result;
58650
58651   arg1 = (Dali::Toolkit::Builder *)jarg1;
58652   if (!jarg2) {
58653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58654     return 0;
58655   }
58656   std::string arg2_str(jarg2);
58657   arg2 = &arg2_str;
58658   {
58659     try {
58660       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58661     } catch (std::out_of_range& e) {
58662       {
58663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (std::exception& e) {
58666       {
58667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58668       };
58669     } catch (Dali::DaliException e) {
58670       {
58671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58672       };
58673     } catch (...) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58676       };
58677     }
58678   }
58679
58680   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58681
58682   //argout typemap for const std::string&
58683
58684   return jresult;
58685 }
58686
58687
58688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58689   void * jresult ;
58690   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58691   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58692
58693   arg1 = (Dali::Toolkit::Builder *)jarg1;
58694   {
58695     try {
58696       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58697     } catch (std::out_of_range& e) {
58698       {
58699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58700       };
58701     } catch (std::exception& e) {
58702       {
58703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58704       };
58705     } catch (Dali::DaliException e) {
58706       {
58707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58708       };
58709     } catch (...) {
58710       {
58711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58712       };
58713     }
58714   }
58715
58716   jresult = (void *)result;
58717   return jresult;
58718 }
58719
58720
58721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58722   void * jresult ;
58723   Dali::Toolkit::TransitionData *result = 0 ;
58724
58725   {
58726     try {
58727       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58728     } catch (std::out_of_range& e) {
58729       {
58730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58731       };
58732     } catch (std::exception& e) {
58733       {
58734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58735       };
58736     } catch (Dali::DaliException e) {
58737       {
58738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58739       };
58740     } catch (...) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58743       };
58744     }
58745   }
58746
58747   jresult = (void *)result;
58748   return jresult;
58749 }
58750
58751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58752   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58753
58754   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58755   {
58756     try {
58757       delete arg1;
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58765       };
58766     } catch (Dali::DaliException e) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58773       };
58774     }
58775   }
58776
58777 }
58778
58779
58780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58781   void * jresult ;
58782   Dali::Property::Map *arg1 = 0 ;
58783   Dali::Toolkit::TransitionData result;
58784
58785   arg1 = (Dali::Property::Map *)jarg1;
58786   if (!arg1) {
58787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58788     return 0;
58789   }
58790   {
58791     try {
58792       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58793     } catch (std::out_of_range& e) {
58794       {
58795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58796       };
58797     } catch (std::exception& e) {
58798       {
58799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58800       };
58801     } catch (Dali::DaliException e) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58804       };
58805     } catch (...) {
58806       {
58807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58808       };
58809     }
58810   }
58811
58812   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58813   return jresult;
58814 }
58815
58816
58817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58818   void * jresult ;
58819   Dali::Property::Array *arg1 = 0 ;
58820   Dali::Toolkit::TransitionData result;
58821
58822   arg1 = (Dali::Property::Array *)jarg1;
58823   if (!arg1) {
58824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58825     return 0;
58826   }
58827   {
58828     try {
58829       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58830     } catch (std::out_of_range& e) {
58831       {
58832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58833       };
58834     } catch (std::exception& e) {
58835       {
58836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58837       };
58838     } catch (Dali::DaliException e) {
58839       {
58840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58841       };
58842     } catch (...) {
58843       {
58844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58845       };
58846     }
58847   }
58848
58849   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58850   return jresult;
58851 }
58852
58853
58854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58855   void * jresult ;
58856   Dali::BaseHandle arg1 ;
58857   Dali::BaseHandle *argp1 ;
58858   Dali::Toolkit::TransitionData result;
58859
58860   argp1 = (Dali::BaseHandle *)jarg1;
58861   if (!argp1) {
58862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58863     return 0;
58864   }
58865   arg1 = *argp1;
58866   {
58867     try {
58868       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58869     } catch (std::out_of_range& e) {
58870       {
58871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58872       };
58873     } catch (std::exception& e) {
58874       {
58875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (Dali::DaliException e) {
58878       {
58879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887
58888   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58889   return jresult;
58890 }
58891
58892
58893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58894   void * jresult ;
58895   Dali::Toolkit::TransitionData *arg1 = 0 ;
58896   Dali::Toolkit::TransitionData *result = 0 ;
58897
58898   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58899   if (!arg1) {
58900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58901     return 0;
58902   }
58903   {
58904     try {
58905       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58906     } catch (std::out_of_range& e) {
58907       {
58908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58909       };
58910     } catch (std::exception& e) {
58911       {
58912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58913       };
58914     } catch (Dali::DaliException e) {
58915       {
58916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58917       };
58918     } catch (...) {
58919       {
58920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58921       };
58922     }
58923   }
58924
58925   jresult = (void *)result;
58926   return jresult;
58927 }
58928
58929
58930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58931   void * jresult ;
58932   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58933   Dali::Toolkit::TransitionData *arg2 = 0 ;
58934   Dali::Toolkit::TransitionData *result = 0 ;
58935
58936   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58937   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58938   if (!arg2) {
58939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58940     return 0;
58941   }
58942   {
58943     try {
58944       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58945     } catch (std::out_of_range& e) {
58946       {
58947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58948       };
58949     } catch (std::exception& e) {
58950       {
58951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58952       };
58953     } catch (Dali::DaliException e) {
58954       {
58955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58956       };
58957     } catch (...) {
58958       {
58959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58960       };
58961     }
58962   }
58963
58964   jresult = (void *)result;
58965   return jresult;
58966 }
58967
58968
58969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58970   unsigned long jresult ;
58971   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58972   size_t result;
58973
58974   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58975   {
58976     try {
58977       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58978     } catch (std::out_of_range& e) {
58979       {
58980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (std::exception& e) {
58983       {
58984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58985       };
58986     } catch (Dali::DaliException e) {
58987       {
58988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58989       };
58990     } catch (...) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58993       };
58994     }
58995   }
58996
58997   jresult = (unsigned long)result;
58998   return jresult;
58999 }
59000
59001
59002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59003   void * jresult ;
59004   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59005   size_t arg2 ;
59006   Dali::Property::Map result;
59007
59008   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59009   arg2 = (size_t)jarg2;
59010   {
59011     try {
59012       result = (arg1)->GetAnimatorAt(arg2);
59013     } catch (std::out_of_range& e) {
59014       {
59015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (std::exception& e) {
59018       {
59019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (Dali::DaliException e) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59024       };
59025     } catch (...) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59028       };
59029     }
59030   }
59031
59032   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59033   return jresult;
59034 }
59035
59036
59037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59038   int jresult ;
59039   int result;
59040
59041   {
59042     try {
59043       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59044     } catch (std::out_of_range& e) {
59045       {
59046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59047       };
59048     } catch (std::exception& e) {
59049       {
59050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (Dali::DaliException e) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59055       };
59056     } catch (...) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59059       };
59060     }
59061   }
59062
59063   jresult = (int)result;
59064   return jresult;
59065 }
59066
59067
59068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59069   int jresult ;
59070   int result;
59071
59072   {
59073     try {
59074       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59075     } catch (std::out_of_range& e) {
59076       {
59077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59078       };
59079     } catch (std::exception& e) {
59080       {
59081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59082       };
59083     } catch (Dali::DaliException e) {
59084       {
59085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59086       };
59087     } catch (...) {
59088       {
59089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59090       };
59091     }
59092   }
59093
59094   jresult = (int)result;
59095   return jresult;
59096 }
59097
59098
59099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59100   int jresult ;
59101   int result;
59102
59103   {
59104     try {
59105       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59106     } catch (std::out_of_range& e) {
59107       {
59108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59109       };
59110     } catch (std::exception& e) {
59111       {
59112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59113       };
59114     } catch (Dali::DaliException e) {
59115       {
59116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59117       };
59118     } catch (...) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59121       };
59122     }
59123   }
59124
59125   jresult = (int)result;
59126   return jresult;
59127 }
59128
59129
59130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59131   int jresult ;
59132   int result;
59133
59134   {
59135     try {
59136       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59137     } catch (std::out_of_range& e) {
59138       {
59139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59140       };
59141     } catch (std::exception& e) {
59142       {
59143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (Dali::DaliException e) {
59146       {
59147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59148       };
59149     } catch (...) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59152       };
59153     }
59154   }
59155
59156   jresult = (int)result;
59157   return jresult;
59158 }
59159
59160
59161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59162   int jresult ;
59163   int result;
59164
59165   {
59166     try {
59167       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59168     } catch (std::out_of_range& e) {
59169       {
59170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59171       };
59172     } catch (std::exception& e) {
59173       {
59174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59175       };
59176     } catch (Dali::DaliException e) {
59177       {
59178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59179       };
59180     } catch (...) {
59181       {
59182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59183       };
59184     }
59185   }
59186
59187   jresult = (int)result;
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59193   int jresult ;
59194   int result;
59195
59196   {
59197     try {
59198       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59199     } catch (std::out_of_range& e) {
59200       {
59201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59202       };
59203     } catch (std::exception& e) {
59204       {
59205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59206       };
59207     } catch (Dali::DaliException e) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59214       };
59215     }
59216   }
59217
59218   jresult = (int)result;
59219   return jresult;
59220 }
59221
59222
59223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59224   int jresult ;
59225   int result;
59226
59227   {
59228     try {
59229       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59230     } catch (std::out_of_range& e) {
59231       {
59232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59233       };
59234     } catch (std::exception& e) {
59235       {
59236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59237       };
59238     } catch (Dali::DaliException e) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59241       };
59242     } catch (...) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59245       };
59246     }
59247   }
59248
59249   jresult = (int)result;
59250   return jresult;
59251 }
59252
59253
59254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59255   int jresult ;
59256   int result;
59257
59258   {
59259     try {
59260       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59261     } catch (std::out_of_range& e) {
59262       {
59263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59264       };
59265     } catch (std::exception& e) {
59266       {
59267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (Dali::DaliException e) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59272       };
59273     } catch (...) {
59274       {
59275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59276       };
59277     }
59278   }
59279
59280   jresult = (int)result;
59281   return jresult;
59282 }
59283
59284
59285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59286   int jresult ;
59287   int result;
59288
59289   {
59290     try {
59291       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59292     } catch (std::out_of_range& e) {
59293       {
59294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59295       };
59296     } catch (std::exception& e) {
59297       {
59298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59299       };
59300     } catch (Dali::DaliException e) {
59301       {
59302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59303       };
59304     } catch (...) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59307       };
59308     }
59309   }
59310
59311   jresult = (int)result;
59312   return jresult;
59313 }
59314
59315
59316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59317   int jresult ;
59318   int result;
59319
59320   {
59321     try {
59322       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59323     } catch (std::out_of_range& e) {
59324       {
59325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (std::exception& e) {
59328       {
59329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59330       };
59331     } catch (Dali::DaliException e) {
59332       {
59333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59334       };
59335     } catch (...) {
59336       {
59337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59338       };
59339     }
59340   }
59341
59342   jresult = (int)result;
59343   return jresult;
59344 }
59345
59346
59347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59348   int jresult ;
59349   int result;
59350
59351   {
59352     try {
59353       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59354     } catch (std::out_of_range& e) {
59355       {
59356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59357       };
59358     } catch (std::exception& e) {
59359       {
59360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59361       };
59362     } catch (Dali::DaliException e) {
59363       {
59364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59365       };
59366     } catch (...) {
59367       {
59368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59369       };
59370     }
59371   }
59372
59373   jresult = (int)result;
59374   return jresult;
59375 }
59376
59377
59378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59379   int jresult ;
59380   int result;
59381
59382   {
59383     try {
59384       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59385     } catch (std::out_of_range& e) {
59386       {
59387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59388       };
59389     } catch (std::exception& e) {
59390       {
59391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59392       };
59393     } catch (Dali::DaliException e) {
59394       {
59395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59396       };
59397     } catch (...) {
59398       {
59399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59400       };
59401     }
59402   }
59403
59404   jresult = (int)result;
59405   return jresult;
59406 }
59407
59408
59409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59410   int jresult ;
59411   int result;
59412
59413   {
59414     try {
59415       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59416     } catch (std::out_of_range& e) {
59417       {
59418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59419       };
59420     } catch (std::exception& e) {
59421       {
59422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59423       };
59424     } catch (Dali::DaliException e) {
59425       {
59426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59427       };
59428     } catch (...) {
59429       {
59430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59431       };
59432     }
59433   }
59434
59435   jresult = (int)result;
59436   return jresult;
59437 }
59438
59439
59440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59441   int jresult ;
59442   int result;
59443
59444   {
59445     try {
59446       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59447     } catch (std::out_of_range& e) {
59448       {
59449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59450       };
59451     } catch (std::exception& e) {
59452       {
59453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59454       };
59455     } catch (Dali::DaliException e) {
59456       {
59457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59458       };
59459     } catch (...) {
59460       {
59461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59462       };
59463     }
59464   }
59465
59466   jresult = (int)result;
59467   return jresult;
59468 }
59469
59470
59471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59472   void * jresult ;
59473   Dali::Toolkit::Control result;
59474
59475   {
59476     try {
59477       result = Dali::Toolkit::Internal::Control::New();
59478     } catch (std::out_of_range& e) {
59479       {
59480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59481       };
59482     } catch (std::exception& e) {
59483       {
59484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59485       };
59486     } catch (Dali::DaliException e) {
59487       {
59488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59489       };
59490     } catch (...) {
59491       {
59492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59493       };
59494     }
59495   }
59496
59497   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59498   return jresult;
59499 }
59500
59501
59502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59504   std::string *arg2 = 0 ;
59505
59506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59507   if (!jarg2) {
59508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59509     return ;
59510   }
59511   std::string arg2_str(jarg2);
59512   arg2 = &arg2_str;
59513   {
59514     try {
59515       (arg1)->SetStyleName((std::string const &)*arg2);
59516     } catch (std::out_of_range& e) {
59517       {
59518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59519       };
59520     } catch (std::exception& e) {
59521       {
59522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59523       };
59524     } catch (Dali::DaliException e) {
59525       {
59526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59527       };
59528     } catch (...) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59531       };
59532     }
59533   }
59534
59535
59536   //argout typemap for const std::string&
59537
59538 }
59539
59540
59541 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59542   char * jresult ;
59543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59544   std::string *result = 0 ;
59545
59546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59547   {
59548     try {
59549       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59550     } catch (std::out_of_range& e) {
59551       {
59552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (std::exception& e) {
59555       {
59556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (Dali::DaliException e) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59561       };
59562     } catch (...) {
59563       {
59564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59565       };
59566     }
59567   }
59568
59569   jresult = SWIG_csharp_string_callback(result->c_str());
59570   return jresult;
59571 }
59572
59573
59574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59576   Dali::Vector4 *arg2 = 0 ;
59577
59578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59579   arg2 = (Dali::Vector4 *)jarg2;
59580   if (!arg2) {
59581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59582     return ;
59583   }
59584   {
59585     try {
59586       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59587     } catch (std::out_of_range& e) {
59588       {
59589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59590       };
59591     } catch (std::exception& e) {
59592       {
59593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59594       };
59595     } catch (Dali::DaliException e) {
59596       {
59597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59598       };
59599     } catch (...) {
59600       {
59601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59602       };
59603     }
59604   }
59605
59606 }
59607
59608
59609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59610   void * jresult ;
59611   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59612   Dali::Vector4 result;
59613
59614   arg1 = (Dali::Handle *)jarg1;
59615   {
59616     try {
59617       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59618       if (resultMap)
59619       {
59620         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59621         if(type && type->Get<int>() == Visual::COLOR )
59622         {
59623           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59624           if (value)
59625           {
59626             result = value->Get<Vector4>();
59627           }
59628         }
59629       }
59630     } catch (std::out_of_range& e) {
59631       {
59632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59633       };
59634     } catch (std::exception& e) {
59635       {
59636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (Dali::DaliException e) {
59639       {
59640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59641       };
59642     } catch (...) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59645       };
59646     }
59647   }
59648
59649   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59650   return jresult;
59651 }
59652
59653
59654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59656   Dali::Property::Map *arg2 = 0 ;
59657
59658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59659   arg2 = (Dali::Property::Map *)jarg2;
59660   if (!arg2) {
59661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59662     return ;
59663   }
59664   {
59665     try {
59666       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59667     } catch (std::out_of_range& e) {
59668       {
59669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59670       };
59671     } catch (std::exception& e) {
59672       {
59673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59674       };
59675     } catch (Dali::DaliException e) {
59676       {
59677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59678       };
59679     } catch (...) {
59680       {
59681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59682       };
59683     }
59684   }
59685
59686 }
59687
59688
59689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59691
59692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59693   {
59694     try {
59695       (arg1)->ClearBackground();
59696     } catch (std::out_of_range& e) {
59697       {
59698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59699       };
59700     } catch (std::exception& e) {
59701       {
59702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59703       };
59704     } catch (Dali::DaliException e) {
59705       {
59706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59711       };
59712     }
59713   }
59714
59715 }
59716
59717
59718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59720   Dali::Gesture::Type arg2 ;
59721
59722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59723   arg2 = (Dali::Gesture::Type)jarg2;
59724   {
59725     try {
59726       (arg1)->EnableGestureDetection(arg2);
59727     } catch (std::out_of_range& e) {
59728       {
59729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59730       };
59731     } catch (std::exception& e) {
59732       {
59733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59734       };
59735     } catch (Dali::DaliException e) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59738       };
59739     } catch (...) {
59740       {
59741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59742       };
59743     }
59744   }
59745
59746 }
59747
59748
59749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59750   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59751   Dali::Gesture::Type arg2 ;
59752
59753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59754   arg2 = (Dali::Gesture::Type)jarg2;
59755   {
59756     try {
59757       (arg1)->DisableGestureDetection(arg2);
59758     } catch (std::out_of_range& e) {
59759       {
59760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59761       };
59762     } catch (std::exception& e) {
59763       {
59764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59765       };
59766     } catch (Dali::DaliException e) {
59767       {
59768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59769       };
59770     } catch (...) {
59771       {
59772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59773       };
59774     }
59775   }
59776
59777 }
59778
59779
59780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59781   void * jresult ;
59782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59783   Dali::PinchGestureDetector result;
59784
59785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59786   {
59787     try {
59788       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59789     } catch (std::out_of_range& e) {
59790       {
59791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59792       };
59793     } catch (std::exception& e) {
59794       {
59795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59796       };
59797     } catch (Dali::DaliException e) {
59798       {
59799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59800       };
59801     } catch (...) {
59802       {
59803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59804       };
59805     }
59806   }
59807
59808   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59809   return jresult;
59810 }
59811
59812
59813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59814   void * jresult ;
59815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59816   Dali::PanGestureDetector result;
59817
59818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59819   {
59820     try {
59821       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59822     } catch (std::out_of_range& e) {
59823       {
59824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (std::exception& e) {
59827       {
59828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59829       };
59830     } catch (Dali::DaliException e) {
59831       {
59832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59833       };
59834     } catch (...) {
59835       {
59836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59837       };
59838     }
59839   }
59840
59841   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59842   return jresult;
59843 }
59844
59845
59846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59847   void * jresult ;
59848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59849   Dali::TapGestureDetector result;
59850
59851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59852   {
59853     try {
59854       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59855     } catch (std::out_of_range& e) {
59856       {
59857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (std::exception& e) {
59860       {
59861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59862       };
59863     } catch (Dali::DaliException e) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59866       };
59867     } catch (...) {
59868       {
59869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59870       };
59871     }
59872   }
59873
59874   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59875   return jresult;
59876 }
59877
59878
59879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59880   void * jresult ;
59881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59882   Dali::LongPressGestureDetector result;
59883
59884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59885   {
59886     try {
59887       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59888     } catch (std::out_of_range& e) {
59889       {
59890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59891       };
59892     } catch (std::exception& e) {
59893       {
59894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (Dali::DaliException e) {
59897       {
59898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59899       };
59900     } catch (...) {
59901       {
59902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59903       };
59904     }
59905   }
59906
59907   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59908   return jresult;
59909 }
59910
59911
59912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59914   bool arg2 ;
59915
59916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59917   arg2 = jarg2 ? true : false;
59918   {
59919     try {
59920       (arg1)->SetKeyboardNavigationSupport(arg2);
59921     } catch (std::out_of_range& e) {
59922       {
59923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59924       };
59925     } catch (std::exception& e) {
59926       {
59927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59928       };
59929     } catch (Dali::DaliException e) {
59930       {
59931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59932       };
59933     } catch (...) {
59934       {
59935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59936       };
59937     }
59938   }
59939
59940 }
59941
59942
59943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59944   unsigned int jresult ;
59945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59946   bool result;
59947
59948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59949   {
59950     try {
59951       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (Dali::DaliException e) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59963       };
59964     } catch (...) {
59965       {
59966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59967       };
59968     }
59969   }
59970
59971   jresult = result;
59972   return jresult;
59973 }
59974
59975
59976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59978
59979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59980   {
59981     try {
59982       (arg1)->SetKeyInputFocus();
59983     } catch (std::out_of_range& e) {
59984       {
59985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59986       };
59987     } catch (std::exception& e) {
59988       {
59989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59990       };
59991     } catch (Dali::DaliException e) {
59992       {
59993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59994       };
59995     } catch (...) {
59996       {
59997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59998       };
59999     }
60000   }
60001
60002 }
60003
60004
60005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60006   unsigned int jresult ;
60007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60008   bool result;
60009
60010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60011   {
60012     try {
60013       result = (bool)(arg1)->HasKeyInputFocus();
60014     } catch (std::out_of_range& e) {
60015       {
60016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60017       };
60018     } catch (std::exception& e) {
60019       {
60020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60021       };
60022     } catch (Dali::DaliException e) {
60023       {
60024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60025       };
60026     } catch (...) {
60027       {
60028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60029       };
60030     }
60031   }
60032
60033   jresult = result;
60034   return jresult;
60035 }
60036
60037
60038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60040
60041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60042   {
60043     try {
60044       (arg1)->ClearKeyInputFocus();
60045     } catch (std::out_of_range& e) {
60046       {
60047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60048       };
60049     } catch (std::exception& e) {
60050       {
60051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60052       };
60053     } catch (Dali::DaliException e) {
60054       {
60055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60056       };
60057     } catch (...) {
60058       {
60059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60060       };
60061     }
60062   }
60063
60064 }
60065
60066
60067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60069   bool arg2 ;
60070
60071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60072   arg2 = jarg2 ? true : false;
60073   {
60074     try {
60075       (arg1)->SetAsKeyboardFocusGroup(arg2);
60076     } catch (std::out_of_range& e) {
60077       {
60078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60079       };
60080     } catch (std::exception& e) {
60081       {
60082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60083       };
60084     } catch (Dali::DaliException e) {
60085       {
60086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60087       };
60088     } catch (...) {
60089       {
60090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60091       };
60092     }
60093   }
60094
60095 }
60096
60097
60098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60099   unsigned int jresult ;
60100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60101   bool result;
60102
60103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60104   {
60105     try {
60106       result = (bool)(arg1)->IsKeyboardFocusGroup();
60107     } catch (std::out_of_range& e) {
60108       {
60109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (std::exception& e) {
60112       {
60113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (Dali::DaliException e) {
60116       {
60117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60118       };
60119     } catch (...) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60122       };
60123     }
60124   }
60125
60126   jresult = result;
60127   return jresult;
60128 }
60129
60130
60131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60132   void * jresult ;
60133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60134   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60135
60136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60137   {
60138     try {
60139       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60140     } catch (std::out_of_range& e) {
60141       {
60142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60143       };
60144     } catch (std::exception& e) {
60145       {
60146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60147       };
60148     } catch (Dali::DaliException e) {
60149       {
60150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60151       };
60152     } catch (...) {
60153       {
60154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60155       };
60156     }
60157   }
60158
60159   jresult = (void *)result;
60160   return jresult;
60161 }
60162
60163
60164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60165   void * jresult ;
60166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60167   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60168
60169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60170   {
60171     try {
60172       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60173     } catch (std::out_of_range& e) {
60174       {
60175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60176       };
60177     } catch (std::exception& e) {
60178       {
60179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60180       };
60181     } catch (Dali::DaliException e) {
60182       {
60183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60184       };
60185     } catch (...) {
60186       {
60187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60188       };
60189     }
60190   }
60191
60192   jresult = (void *)result;
60193   return jresult;
60194 }
60195
60196
60197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60198   void * jresult ;
60199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60200   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60201
60202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60203   {
60204     try {
60205       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60206     } catch (std::out_of_range& e) {
60207       {
60208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (std::exception& e) {
60211       {
60212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60213       };
60214     } catch (Dali::DaliException e) {
60215       {
60216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60217       };
60218     } catch (...) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60221       };
60222     }
60223   }
60224
60225   jresult = (void *)result;
60226   return jresult;
60227 }
60228
60229
60230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
60231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60232   int arg2 ;
60233   SwigDirector_ViewImpl *darg = 0;
60234
60235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60236   arg2 = (int)jarg2;
60237   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60238   if(!darg) {
60239     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60240     return;
60241   }
60242   {
60243     try {
60244       if(darg) {
60245         (darg)->OnSceneConnection(arg2);
60246       }
60247     } catch (std::out_of_range& e) {
60248       {
60249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60250       };
60251     } catch (std::exception& e) {
60252       {
60253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60254       };
60255     } catch (Dali::DaliException e) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60258       };
60259     } catch (...) {
60260       {
60261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60262       };
60263     }
60264   }
60265
60266 }
60267
60268
60269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60271   int arg2 ;
60272   SwigDirector_ViewImpl *darg = 0;
60273
60274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60275   arg2 = (int)jarg2;
60276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60277   if(!darg) {
60278     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60279     return;
60280   }
60281   {
60282     try {
60283       if(darg) {
60284         (darg)->OnSceneConnectionSwigPublic(arg2);
60285       }
60286     } catch (std::out_of_range& e) {
60287       {
60288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60289       };
60290     } catch (std::exception& e) {
60291       {
60292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60293       };
60294     } catch (Dali::DaliException e) {
60295       {
60296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60297       };
60298     } catch (...) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60301       };
60302     }
60303   }
60304
60305 }
60306
60307
60308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
60309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60310   SwigDirector_ViewImpl *darg = 0;
60311
60312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60313   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60314   if(!darg) {
60315     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60316     return;
60317   }
60318   {
60319     try {
60320       if(darg) {
60321         (darg)->OnSceneDisconnection();
60322       }
60323     } catch (std::out_of_range& e) {
60324       {
60325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60326       };
60327     } catch (std::exception& e) {
60328       {
60329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60330       };
60331     } catch (Dali::DaliException e) {
60332       {
60333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60334       };
60335     } catch (...) {
60336       {
60337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60338       };
60339     }
60340   }
60341
60342 }
60343
60344
60345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60347   SwigDirector_ViewImpl *darg = 0;
60348
60349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60350   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60351   if(!darg) {
60352     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60353     return;
60354   }
60355   {
60356     try {
60357       if(darg) {
60358         (darg)->OnSceneDisconnectionSwigPublic();
60359       }
60360     } catch (std::out_of_range& e) {
60361       {
60362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60363       };
60364     } catch (std::exception& e) {
60365       {
60366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60367       };
60368     } catch (Dali::DaliException e) {
60369       {
60370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60371       };
60372     } catch (...) {
60373       {
60374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60375       };
60376     }
60377   }
60378
60379 }
60380
60381
60382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60384   Dali::Actor *arg2 = 0 ;
60385   SwigDirector_ViewImpl *darg = 0;
60386
60387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60388   arg2 = (Dali::Actor *)jarg2;
60389   if (!arg2) {
60390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60391     return ;
60392   }
60393   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60394   if(!darg) {
60395     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60396     return;
60397   }
60398   {
60399     try {
60400       if(darg) {
60401         (darg)->OnChildAdd(*arg2);
60402       }
60403     } catch (std::out_of_range& e) {
60404       {
60405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60406       };
60407     } catch (std::exception& e) {
60408       {
60409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60410       };
60411     } catch (Dali::DaliException e) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60414       };
60415     } catch (...) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60418       };
60419     }
60420   }
60421
60422 }
60423
60424
60425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60426   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60427   Dali::Actor *arg2 = 0 ;
60428   SwigDirector_ViewImpl *darg = 0;
60429
60430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60431   arg2 = (Dali::Actor *)jarg2;
60432   if (!arg2) {
60433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & 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       if(darg) {
60444           (darg)->OnChildAddSwigPublic(*arg2);
60445       }
60446     } catch (std::out_of_range& e) {
60447       {
60448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60449       };
60450     } catch (std::exception& e) {
60451       {
60452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60453       };
60454     } catch (Dali::DaliException e) {
60455       {
60456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60457       };
60458     } catch (...) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60461       };
60462     }
60463   }
60464
60465 }
60466
60467
60468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60470   Dali::Actor *arg2 = 0 ;
60471   SwigDirector_ViewImpl *darg = 0;
60472
60473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60474   arg2 = (Dali::Actor *)jarg2;
60475   if (!arg2) {
60476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60477     return ;
60478   }
60479   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60480   if(!darg) {
60481     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60482     return;
60483   }
60484   {
60485     try {
60486       if(darg) {
60487         (darg)->OnChildRemove(*arg2);
60488       }
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60496       };
60497     } catch (Dali::DaliException e) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60504       };
60505     }
60506   }
60507
60508 }
60509
60510
60511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60513   Dali::Actor *arg2 = 0 ;
60514   SwigDirector_ViewImpl *darg = 0;
60515
60516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60517   arg2 = (Dali::Actor *)jarg2;
60518   if (!arg2) {
60519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60520     return ;
60521   }
60522   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60523   if(!darg) {
60524     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60525     return;
60526   }
60527   {
60528     try {
60529       if(darg) {
60530         (darg)->OnChildRemoveSwigPublic(*arg2);
60531       }
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60539       };
60540     } catch (Dali::DaliException e) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60543       };
60544     } catch (...) {
60545       {
60546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60547       };
60548     }
60549   }
60550
60551 }
60552
60553
60554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60556   Dali::Property::Index arg2 ;
60557   Dali::Property::Value arg3 ;
60558   Dali::Property::Value *argp3 ;
60559   SwigDirector_ViewImpl *darg = 0;
60560
60561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60562   arg2 = (Dali::Property::Index)jarg2;
60563   argp3 = (Dali::Property::Value *)jarg3;
60564   if (!argp3) {
60565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60566     return ;
60567   }
60568   arg3 = *argp3;
60569   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60570   if (!darg) {
60571     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60572     return;
60573   }
60574   {
60575     try {
60576       (darg)->OnPropertySet(arg2,arg3);
60577     } catch (std::out_of_range& e) {
60578       {
60579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60580       };
60581     } catch (std::exception& e) {
60582       {
60583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60584       };
60585     } catch (Dali::DaliException e) {
60586       {
60587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60588       };
60589     } catch (...) {
60590       {
60591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60592       };
60593     }
60594   }
60595
60596 }
60597
60598
60599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60601   Dali::Property::Index arg2 ;
60602   Dali::Property::Value arg3 ;
60603   Dali::Property::Value *argp3 ;
60604   SwigDirector_ViewImpl *darg = 0;
60605
60606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60607   arg2 = (Dali::Property::Index)jarg2;
60608   argp3 = (Dali::Property::Value *)jarg3;
60609   if (!argp3) {
60610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60611     return ;
60612   }
60613   arg3 = *argp3;
60614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60615   if (!darg) {
60616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60617     return;
60618   }
60619   {
60620     try {
60621       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60622     } catch (std::out_of_range& e) {
60623       {
60624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60625       };
60626     } catch (std::exception& e) {
60627       {
60628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60629       };
60630     } catch (Dali::DaliException e) {
60631       {
60632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60633       };
60634     } catch (...) {
60635       {
60636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60637       };
60638     }
60639   }
60640
60641 }
60642
60643
60644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60646   Dali::Vector3 *arg2 = 0 ;
60647   SwigDirector_ViewImpl *darg = 0;
60648
60649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60650   arg2 = (Dali::Vector3 *)jarg2;
60651   if (!arg2) {
60652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60653     return ;
60654   }
60655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60656   if (!darg) {
60657     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60658     return;
60659   }
60660   {
60661     try {
60662       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60663     } catch (std::out_of_range& e) {
60664       {
60665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60666       };
60667     } catch (std::exception& e) {
60668       {
60669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60670       };
60671     } catch (Dali::DaliException e) {
60672       {
60673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60674       };
60675     } catch (...) {
60676       {
60677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60678       };
60679     }
60680   }
60681
60682 }
60683
60684
60685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60687   Dali::Vector3 *arg2 = 0 ;
60688   SwigDirector_ViewImpl *darg = 0;
60689
60690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60691   arg2 = (Dali::Vector3 *)jarg2;
60692   if (!arg2) {
60693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60694     return ;
60695   }
60696   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60697   if (!darg) {
60698     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60699     return;
60700   }
60701   {
60702     try {
60703       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60704     } catch (std::out_of_range& e) {
60705       {
60706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60707       };
60708     } catch (std::exception& e) {
60709       {
60710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60711       };
60712     } catch (Dali::DaliException e) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60715       };
60716     } catch (...) {
60717       {
60718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60719       };
60720     }
60721   }
60722
60723 }
60724
60725
60726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60728   Dali::Animation *arg2 = 0 ;
60729   Dali::Vector3 *arg3 = 0 ;
60730   SwigDirector_ViewImpl *darg = 0;
60731
60732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60733   arg2 = (Dali::Animation *)jarg2;
60734   if (!arg2) {
60735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60736     return ;
60737   }
60738   arg3 = (Dali::Vector3 *)jarg3;
60739   if (!arg3) {
60740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60741     return ;
60742   }
60743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60744   if (!darg) {
60745     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60746     return;
60747   }
60748   {
60749     try {
60750       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60751     } catch (std::out_of_range& e) {
60752       {
60753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60754       };
60755     } catch (std::exception& e) {
60756       {
60757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60758       };
60759     } catch (Dali::DaliException e) {
60760       {
60761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60766       };
60767     }
60768   }
60769
60770 }
60771
60772
60773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60775   Dali::Animation *arg2 = 0 ;
60776   Dali::Vector3 *arg3 = 0 ;
60777   SwigDirector_ViewImpl *darg = 0;
60778
60779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60780   arg2 = (Dali::Animation *)jarg2;
60781   if (!arg2) {
60782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60783     return ;
60784   }
60785   arg3 = (Dali::Vector3 *)jarg3;
60786   if (!arg3) {
60787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60788     return ;
60789   }
60790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60791   if (!darg) {
60792     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60793     return;
60794   }
60795   {
60796     try {
60797       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60798     } catch (std::out_of_range& e) {
60799       {
60800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60801       };
60802     } catch (std::exception& e) {
60803       {
60804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60805       };
60806     } catch (Dali::DaliException e) {
60807       {
60808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60809       };
60810     } catch (...) {
60811       {
60812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60813       };
60814     }
60815   }
60816 }
60817
60818
60819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60820   unsigned int jresult ;
60821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60822   Dali::HoverEvent *arg2 = 0 ;
60823   SwigDirector_ViewImpl *darg = 0;
60824   bool result;
60825
60826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60827   arg2 = (Dali::HoverEvent *)jarg2;
60828   if (!arg2) {
60829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60830     return 0;
60831   }
60832   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60833   if (!darg) {
60834     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60835     return 0;
60836   }
60837   {
60838     try {
60839       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60840     } catch (std::out_of_range& e) {
60841       {
60842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60843       };
60844     } catch (std::exception& e) {
60845       {
60846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60847       };
60848     } catch (Dali::DaliException e) {
60849       {
60850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60851       };
60852     } catch (...) {
60853       {
60854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60855       };
60856     }
60857   }
60858
60859   jresult = result;
60860   return jresult;
60861 }
60862
60863
60864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60865   unsigned int jresult ;
60866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60867   Dali::HoverEvent *arg2 = 0 ;
60868   SwigDirector_ViewImpl *darg = 0;
60869   bool result;
60870
60871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60872   arg2 = (Dali::HoverEvent *)jarg2;
60873   if (!arg2) {
60874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60875     return 0;
60876   }
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 0;
60881   }
60882   {
60883     try {
60884       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60885     } catch (std::out_of_range& e) {
60886       {
60887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (std::exception& e) {
60890       {
60891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60892       };
60893     } catch (Dali::DaliException e) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60896       };
60897     } catch (...) {
60898       {
60899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60900       };
60901     }
60902   }
60903
60904   jresult = result;
60905   return jresult;
60906 }
60907
60908
60909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60910   unsigned int jresult ;
60911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60912   Dali::KeyEvent *arg2 = 0 ;
60913   SwigDirector_ViewImpl *darg = 0;
60914   bool result;
60915
60916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60917   arg2 = (Dali::KeyEvent *)jarg2;
60918   if (!arg2) {
60919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60920     return 0;
60921   }
60922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60923   if (!darg) {
60924     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60925     return 0;
60926   }
60927   {
60928     try {
60929       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60937       };
60938     } catch (Dali::DaliException e) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60941       };
60942     } catch (...) {
60943       {
60944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60945       };
60946     }
60947   }
60948
60949   jresult = result;
60950   return jresult;
60951 }
60952
60953
60954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60955   unsigned int jresult ;
60956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60957   Dali::KeyEvent *arg2 = 0 ;
60958   SwigDirector_ViewImpl *darg = 0;
60959   bool result;
60960
60961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60962   arg2 = (Dali::KeyEvent *)jarg2;
60963   if (!arg2) {
60964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60965     return 0;
60966   }
60967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60968   if (!darg) {
60969     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60970     return 0;
60971   }
60972   {
60973     try {
60974       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60975     } catch (std::out_of_range& e) {
60976       {
60977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60978       };
60979     } catch (std::exception& e) {
60980       {
60981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (Dali::DaliException e) {
60984       {
60985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60986       };
60987     } catch (...) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60990       };
60991     }
60992   }
60993
60994   jresult = result;
60995   return jresult;
60996 }
60997
60998
60999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61000   unsigned int jresult ;
61001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61002   Dali::WheelEvent *arg2 = 0 ;
61003   SwigDirector_ViewImpl *darg = 0;
61004   bool result;
61005
61006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61007   arg2 = (Dali::WheelEvent *)jarg2;
61008   if (!arg2) {
61009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61010     return 0;
61011   }
61012   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61013   if (!darg) {
61014     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61015     return 0;
61016   }
61017   {
61018     try {
61019       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (Dali::DaliException e) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038
61039   jresult = result;
61040   return jresult;
61041 }
61042
61043
61044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61045   unsigned int jresult ;
61046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61047   Dali::WheelEvent *arg2 = 0 ;
61048   SwigDirector_ViewImpl *darg = 0;
61049   bool result;
61050
61051   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61052   arg2 = (Dali::WheelEvent *)jarg2;
61053   if (!arg2) {
61054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61055     return 0;
61056   }
61057   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61058   if (!darg) {
61059     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61060     return 0;
61061   }
61062   {
61063     try {
61064       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61065     } catch (std::out_of_range& e) {
61066       {
61067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61068       };
61069     } catch (std::exception& e) {
61070       {
61071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61072       };
61073     } catch (Dali::DaliException e) {
61074       {
61075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61076       };
61077     } catch (...) {
61078       {
61079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61080       };
61081     }
61082   }
61083
61084   jresult = result;
61085   return jresult;
61086 }
61087
61088
61089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61091   Dali::Vector2 *arg2 = 0 ;
61092   Dali::RelayoutContainer *arg3 = 0 ;
61093   SwigDirector_ViewImpl *darg = 0;
61094
61095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61096   arg2 = (Dali::Vector2 *)jarg2;
61097   if (!arg2) {
61098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61099     return ;
61100   }
61101   arg3 = (Dali::RelayoutContainer *)jarg3;
61102   if (!arg3) {
61103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61104     return ;
61105   }
61106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61107   if (!darg) {
61108     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61109     return;
61110   }
61111   {
61112     try {
61113       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61114     } catch (std::out_of_range& e) {
61115       {
61116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61117       };
61118     } catch (std::exception& e) {
61119       {
61120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61121       };
61122     } catch (Dali::DaliException e) {
61123       {
61124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61125       };
61126     } catch (...) {
61127       {
61128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61129       };
61130     }
61131   }
61132
61133 }
61134
61135
61136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61138   Dali::Vector2 *arg2 = 0 ;
61139   Dali::RelayoutContainer *arg3 = 0 ;
61140   SwigDirector_ViewImpl *darg = 0;
61141
61142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61143   arg2 = (Dali::Vector2 *)jarg2;
61144   if (!arg2) {
61145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61146     return ;
61147   }
61148   arg3 = (Dali::RelayoutContainer *)jarg3;
61149   if (!arg3) {
61150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61151     return ;
61152   }
61153   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61154   if (!darg) {
61155     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61156     return;
61157   }
61158   {
61159     try {
61160       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61161     } catch (std::out_of_range& e) {
61162       {
61163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61164       };
61165     } catch (std::exception& e) {
61166       {
61167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61168       };
61169     } catch (Dali::DaliException e) {
61170       {
61171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61172       };
61173     } catch (...) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61176       };
61177     }
61178   }
61179
61180 }
61181
61182
61183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61185   Dali::ResizePolicy::Type arg2 ;
61186   Dali::Dimension::Type arg3 ;
61187   SwigDirector_ViewImpl *darg = 0;
61188
61189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61190   arg2 = (Dali::ResizePolicy::Type)jarg2;
61191   arg3 = (Dali::Dimension::Type)jarg3;
61192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61193   if (!darg) {
61194     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61195     return;
61196   }
61197   {
61198     try {
61199       (darg)->OnSetResizePolicy(arg2,arg3);
61200     } catch (std::out_of_range& e) {
61201       {
61202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61203       };
61204     } catch (std::exception& e) {
61205       {
61206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61207       };
61208     } catch (Dali::DaliException e) {
61209       {
61210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61211       };
61212     } catch (...) {
61213       {
61214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61215       };
61216     }
61217   }
61218
61219 }
61220
61221
61222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61224   Dali::ResizePolicy::Type arg2 ;
61225   Dali::Dimension::Type arg3 ;
61226   SwigDirector_ViewImpl *darg = 0;
61227
61228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61229   arg2 = (Dali::ResizePolicy::Type)jarg2;
61230   arg3 = (Dali::Dimension::Type)jarg3;
61231   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61232   if (!darg) {
61233     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61234     return;
61235   }
61236   {
61237     try {
61238       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61239     } catch (std::out_of_range& e) {
61240       {
61241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61242       };
61243     } catch (std::exception& e) {
61244       {
61245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61246       };
61247     } catch (Dali::DaliException e) {
61248       {
61249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61250       };
61251     } catch (...) {
61252       {
61253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61254       };
61255     }
61256   }
61257
61258 }
61259
61260
61261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61262   void * jresult ;
61263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61264   SwigDirector_ViewImpl *darg = 0;
61265   Dali::Vector3 result;
61266
61267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61269   if (!darg) {
61270     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61271     return 0;
61272   }
61273   {
61274     try {
61275       result = (darg)->GetNaturalSize();
61276     } catch (std::out_of_range& e) {
61277       {
61278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61279       };
61280     } catch (std::exception& e) {
61281       {
61282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61283       };
61284     } catch (Dali::DaliException e) {
61285       {
61286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61287       };
61288     } catch (...) {
61289       {
61290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61291       };
61292     }
61293   }
61294
61295   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61296   return jresult;
61297 }
61298
61299
61300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61301   void * jresult ;
61302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61303   SwigDirector_ViewImpl *darg = 0;
61304   Dali::Vector3 result;
61305
61306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61308   if (!darg) {
61309     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61310     return 0;
61311   }
61312   {
61313     try {
61314       result = (darg)->GetNaturalSizeSwigPublic();
61315     } catch (std::out_of_range& e) {
61316       {
61317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61318       };
61319     } catch (std::exception& e) {
61320       {
61321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (Dali::DaliException e) {
61324       {
61325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61326       };
61327     } catch (...) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61330       };
61331     }
61332   }
61333
61334   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61335   return jresult;
61336 }
61337
61338
61339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61340   float jresult ;
61341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61342   Dali::Actor *arg2 = 0 ;
61343   Dali::Dimension::Type arg3 ;
61344   SwigDirector_ViewImpl *darg = 0;
61345   float result;
61346
61347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61348   arg2 = (Dali::Actor *)jarg2;
61349   if (!arg2) {
61350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61351     return 0;
61352   }
61353   arg3 = (Dali::Dimension::Type)jarg3;
61354   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61355   if (!darg) {
61356     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61357     return 0;
61358   }
61359   {
61360     try {
61361       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61362     } catch (std::out_of_range& e) {
61363       {
61364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61365       };
61366     } catch (std::exception& e) {
61367       {
61368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61369       };
61370     } catch (Dali::DaliException e) {
61371       {
61372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61373       };
61374     } catch (...) {
61375       {
61376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61377       };
61378     }
61379   }
61380
61381   jresult = result;
61382   return jresult;
61383 }
61384
61385
61386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61387   float jresult ;
61388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61389   Dali::Actor *arg2 = 0 ;
61390   Dali::Dimension::Type arg3 ;
61391   SwigDirector_ViewImpl *darg = 0;
61392   float result;
61393
61394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61395   arg2 = (Dali::Actor *)jarg2;
61396   if (!arg2) {
61397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61398     return 0;
61399   }
61400   arg3 = (Dali::Dimension::Type)jarg3;
61401   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61402   if (!darg) {
61403     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61404     return 0;
61405   }
61406   {
61407     try {
61408       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61409     } catch (std::out_of_range& e) {
61410       {
61411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61412       };
61413     } catch (std::exception& e) {
61414       {
61415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61416       };
61417     } catch (Dali::DaliException e) {
61418       {
61419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61420       };
61421     } catch (...) {
61422       {
61423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61424       };
61425     }
61426   }
61427
61428   jresult = result;
61429   return jresult;
61430 }
61431
61432
61433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61434   float jresult ;
61435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61436   float arg2 ;
61437   SwigDirector_ViewImpl *darg = 0;
61438   float result;
61439
61440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61441   arg2 = (float)jarg2;
61442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61443   if (!darg) {
61444     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61445     return 0;
61446   }
61447   {
61448     try {
61449       result = (float)(darg)->GetHeightForWidth(arg2);
61450     } catch (std::out_of_range& e) {
61451       {
61452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (std::exception& e) {
61455       {
61456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (Dali::DaliException e) {
61459       {
61460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61461       };
61462     } catch (...) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61465       };
61466     }
61467   }
61468
61469   jresult = result;
61470   return jresult;
61471 }
61472
61473
61474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61475   float jresult ;
61476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61477   float arg2 ;
61478   SwigDirector_ViewImpl *darg = 0;
61479   float result;
61480
61481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61482   arg2 = (float)jarg2;
61483   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61484   if (!darg) {
61485     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61486     return 0;
61487   }
61488   {
61489     try {
61490       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61491     } catch (std::out_of_range& e) {
61492       {
61493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (std::exception& e) {
61496       {
61497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61498       };
61499     } catch (Dali::DaliException e) {
61500       {
61501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61502       };
61503     } catch (...) {
61504       {
61505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61506       };
61507     }
61508   }
61509
61510   jresult = result;
61511   return jresult;
61512 }
61513
61514
61515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61516   float jresult ;
61517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61518   float arg2 ;
61519   SwigDirector_ViewImpl *darg = 0;
61520   float result;
61521
61522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61523   arg2 = (float)jarg2;
61524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61525   if (!darg) {
61526     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61527     return 0;
61528   }
61529   {
61530     try {
61531       result = (float)(darg)->GetWidthForHeight(arg2);
61532     } catch (std::out_of_range& e) {
61533       {
61534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61535       };
61536     } catch (std::exception& e) {
61537       {
61538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61539       };
61540     } catch (Dali::DaliException e) {
61541       {
61542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61543       };
61544     } catch (...) {
61545       {
61546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61547       };
61548     }
61549   }
61550
61551   jresult = result;
61552   return jresult;
61553 }
61554
61555
61556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61557   float jresult ;
61558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61559   float arg2 ;
61560   SwigDirector_ViewImpl *darg = 0;
61561   float result;
61562
61563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61564   arg2 = (float)jarg2;
61565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61566   if (!darg) {
61567     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61568     return 0;
61569   }
61570   {
61571     try {
61572       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61573     } catch (std::out_of_range& e) {
61574       {
61575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61576       };
61577     } catch (std::exception& e) {
61578       {
61579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61580       };
61581     } catch (Dali::DaliException e) {
61582       {
61583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61584       };
61585     } catch (...) {
61586       {
61587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61588       };
61589     }
61590   }
61591
61592   jresult = result;
61593   return jresult;
61594 }
61595
61596
61597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61598   unsigned int jresult ;
61599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61600   Dali::Dimension::Type arg2 ;
61601   SwigDirector_ViewImpl *darg = 0;
61602   bool result;
61603
61604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61605   arg2 = (Dali::Dimension::Type)jarg2;
61606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61607   if (!darg) {
61608     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61609     return 0;
61610   }
61611   {
61612     try {
61613       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61614     } catch (std::out_of_range& e) {
61615       {
61616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61617       };
61618     } catch (std::exception& e) {
61619       {
61620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61621       };
61622     } catch (Dali::DaliException e) {
61623       {
61624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61625       };
61626     } catch (...) {
61627       {
61628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61629       };
61630     }
61631   }
61632
61633   jresult = result;
61634   return jresult;
61635 }
61636
61637
61638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61639   unsigned int jresult ;
61640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61641   Dali::Dimension::Type arg2 ;
61642   SwigDirector_ViewImpl *darg = 0;
61643   bool result;
61644
61645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61646   arg2 = (Dali::Dimension::Type)jarg2;
61647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61648   if (!darg) {
61649     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61650     return 0;
61651   }
61652   {
61653     try {
61654       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61655     } catch (std::out_of_range& e) {
61656       {
61657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61658       };
61659     } catch (std::exception& e) {
61660       {
61661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (Dali::DaliException e) {
61664       {
61665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61666       };
61667     } catch (...) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61670       };
61671     }
61672   }
61673
61674   jresult = result;
61675   return jresult;
61676 }
61677
61678
61679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61680   unsigned int jresult ;
61681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61682   SwigDirector_ViewImpl *darg = 0;
61683   bool result;
61684
61685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61687   if (!darg) {
61688     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61689     return 0;
61690   }
61691   {
61692     try {
61693       result = (bool)(darg)->RelayoutDependentOnChildren();
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (Dali::DaliException e) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61705       };
61706     } catch (...) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61709       };
61710     }
61711   }
61712
61713   jresult = result;
61714   return jresult;
61715 }
61716
61717
61718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61719   unsigned int jresult ;
61720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61721   SwigDirector_ViewImpl *darg = 0;
61722   bool result;
61723
61724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61726   if (!darg) {
61727     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61728     return 0;
61729   }
61730   {
61731     try {
61732       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61759   Dali::Dimension::Type arg2 ;
61760   SwigDirector_ViewImpl *darg = 0;
61761
61762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61763   arg2 = (Dali::Dimension::Type)jarg2;
61764   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61765   if (!darg) {
61766     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61767     return;
61768   }
61769   {
61770     try {
61771       (darg)->OnCalculateRelayoutSize(arg2);
61772     } catch (std::out_of_range& e) {
61773       {
61774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61775       };
61776     } catch (std::exception& e) {
61777       {
61778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61779       };
61780     } catch (Dali::DaliException e) {
61781       {
61782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61783       };
61784     } catch (...) {
61785       {
61786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61787       };
61788     }
61789   }
61790
61791 }
61792
61793
61794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61796   Dali::Dimension::Type arg2 ;
61797   SwigDirector_ViewImpl *darg = 0;
61798
61799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61800   arg2 = (Dali::Dimension::Type)jarg2;
61801   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61802   if (!darg) {
61803     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61804     return;
61805   }
61806   {
61807     try {
61808       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61809     } catch (std::out_of_range& e) {
61810       {
61811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61812       };
61813     } catch (std::exception& e) {
61814       {
61815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61816       };
61817     } catch (Dali::DaliException e) {
61818       {
61819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61820       };
61821     } catch (...) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61824       };
61825     }
61826   }
61827
61828 }
61829
61830
61831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61833   float arg2 ;
61834   Dali::Dimension::Type arg3 ;
61835   SwigDirector_ViewImpl *darg = 0;
61836
61837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61838   arg2 = (float)jarg2;
61839   arg3 = (Dali::Dimension::Type)jarg3;
61840   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61841   if (!darg) {
61842     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61843     return;
61844   }
61845   {
61846     try {
61847       (darg)->OnLayoutNegotiated(arg2,arg3);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61863       };
61864     }
61865   }
61866
61867 }
61868
61869
61870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61872   float arg2 ;
61873   Dali::Dimension::Type arg3 ;
61874   SwigDirector_ViewImpl *darg = 0;
61875
61876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61877   arg2 = (float)jarg2;
61878   arg3 = (Dali::Dimension::Type)jarg3;
61879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61880   if (!darg) {
61881     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61882     return;
61883   }
61884   {
61885     try {
61886       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61902       };
61903     }
61904   }
61905
61906 }
61907
61908
61909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61911
61912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61913   {
61914     try {
61915       (arg1)->OnInitialize();
61916     } catch (std::out_of_range& e) {
61917       {
61918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61919       };
61920     } catch (std::exception& e) {
61921       {
61922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61923       };
61924     } catch (Dali::DaliException e) {
61925       {
61926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61927       };
61928     } catch (...) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61931       };
61932     }
61933   }
61934
61935 }
61936
61937
61938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61940
61941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61942   {
61943     try {
61944       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61945     } catch (std::out_of_range& e) {
61946       {
61947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61948       };
61949     } catch (std::exception& e) {
61950       {
61951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61952       };
61953     } catch (Dali::DaliException e) {
61954       {
61955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61956       };
61957     } catch (...) {
61958       {
61959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61960       };
61961     }
61962   }
61963
61964 }
61965
61966
61967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61969   Dali::Toolkit::StyleManager arg2 ;
61970   Dali::StyleChange::Type arg3 ;
61971   Dali::Toolkit::StyleManager *argp2 ;
61972
61973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61974   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61975   if (!argp2) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61977     return ;
61978   }
61979   arg2 = *argp2;
61980   arg3 = (Dali::StyleChange::Type)jarg3;
61981   {
61982     try {
61983       (arg1)->OnStyleChange(arg2,arg3);
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_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62008   Dali::Toolkit::StyleManager arg2 ;
62009   Dali::StyleChange::Type arg3 ;
62010   Dali::Toolkit::StyleManager *argp2 ;
62011
62012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62013   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62014   if (!argp2) {
62015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62016     return ;
62017   }
62018   arg2 = *argp2;
62019   arg3 = (Dali::StyleChange::Type)jarg3;
62020   {
62021     try {
62022       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62023     } catch (std::out_of_range& e) {
62024       {
62025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62026       };
62027     } catch (std::exception& e) {
62028       {
62029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62030       };
62031     } catch (Dali::DaliException e) {
62032       {
62033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62034       };
62035     } catch (...) {
62036       {
62037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62038       };
62039     }
62040   }
62041
62042 }
62043
62044
62045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62046   unsigned int jresult ;
62047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62048   bool result;
62049
62050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62051   {
62052     try {
62053       result = (bool)(arg1)->OnAccessibilityActivated();
62054     } catch (std::out_of_range& e) {
62055       {
62056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62057       };
62058     } catch (std::exception& e) {
62059       {
62060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62061       };
62062     } catch (Dali::DaliException e) {
62063       {
62064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62065       };
62066     } catch (...) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62069       };
62070     }
62071   }
62072
62073   jresult = result;
62074   return jresult;
62075 }
62076
62077
62078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62079   unsigned int jresult ;
62080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62081   bool result;
62082
62083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62084   {
62085     try {
62086       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (Dali::DaliException e) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62102       };
62103     }
62104   }
62105
62106   jresult = result;
62107   return jresult;
62108 }
62109
62110
62111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62112   unsigned int jresult ;
62113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62114   Dali::PanGesture arg2 ;
62115   Dali::PanGesture *argp2 ;
62116   bool result;
62117
62118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62119   argp2 = (Dali::PanGesture *)jarg2;
62120   if (!argp2) {
62121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62122     return 0;
62123   }
62124   arg2 = *argp2;
62125   {
62126     try {
62127       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62128     } catch (std::out_of_range& e) {
62129       {
62130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62131       };
62132     } catch (std::exception& e) {
62133       {
62134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62135       };
62136     } catch (Dali::DaliException e) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62139       };
62140     } catch (...) {
62141       {
62142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62143       };
62144     }
62145   }
62146
62147   jresult = result;
62148   return jresult;
62149 }
62150
62151
62152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62153   unsigned int jresult ;
62154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62155   Dali::PanGesture arg2 ;
62156   Dali::PanGesture *argp2 ;
62157   bool result;
62158
62159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62160   argp2 = (Dali::PanGesture *)jarg2;
62161   if (!argp2) {
62162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62163     return 0;
62164   }
62165   arg2 = *argp2;
62166   {
62167     try {
62168       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62169     } catch (std::out_of_range& e) {
62170       {
62171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62172       };
62173     } catch (std::exception& e) {
62174       {
62175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62176       };
62177     } catch (Dali::DaliException e) {
62178       {
62179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62180       };
62181     } catch (...) {
62182       {
62183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62184       };
62185     }
62186   }
62187
62188   jresult = result;
62189   return jresult;
62190 }
62191
62192
62193
62194
62195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62196   unsigned int jresult ;
62197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62198   bool arg2 ;
62199   bool result;
62200
62201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62202   arg2 = jarg2 ? true : false;
62203   {
62204     try {
62205       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62206     } catch (std::out_of_range& e) {
62207       {
62208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62209       };
62210     } catch (std::exception& e) {
62211       {
62212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62213       };
62214     } catch (Dali::DaliException e) {
62215       {
62216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62217       };
62218     } catch (...) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62221       };
62222     }
62223   }
62224
62225   jresult = result;
62226   return jresult;
62227 }
62228
62229
62230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62231   unsigned int jresult ;
62232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62233   bool arg2 ;
62234   bool result;
62235
62236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62237   arg2 = jarg2 ? true : false;
62238   {
62239     try {
62240       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62241     } catch (std::out_of_range& e) {
62242       {
62243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62244       };
62245     } catch (std::exception& e) {
62246       {
62247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62248       };
62249     } catch (Dali::DaliException e) {
62250       {
62251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62252       };
62253     } catch (...) {
62254       {
62255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62256       };
62257     }
62258   }
62259
62260   jresult = result;
62261   return jresult;
62262 }
62263
62264
62265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62266   unsigned int jresult ;
62267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62268   bool result;
62269
62270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62271   {
62272     try {
62273       result = (bool)(arg1)->OnAccessibilityZoom();
62274     } catch (std::out_of_range& e) {
62275       {
62276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (std::exception& e) {
62279       {
62280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62281       };
62282     } catch (Dali::DaliException e) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62285       };
62286     } catch (...) {
62287       {
62288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62289       };
62290     }
62291   }
62292
62293   jresult = result;
62294   return jresult;
62295 }
62296
62297
62298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62299   unsigned int jresult ;
62300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62301   bool result;
62302
62303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62304   {
62305     try {
62306       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62307     } catch (std::out_of_range& e) {
62308       {
62309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62310       };
62311     } catch (std::exception& e) {
62312       {
62313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62314       };
62315     } catch (Dali::DaliException e) {
62316       {
62317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62318       };
62319     } catch (...) {
62320       {
62321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62322       };
62323     }
62324   }
62325
62326   jresult = result;
62327   return jresult;
62328 }
62329
62330
62331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62333
62334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62335   {
62336     try {
62337       (arg1)->OnKeyInputFocusGained();
62338     } catch (std::out_of_range& e) {
62339       {
62340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (std::exception& e) {
62343       {
62344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62345       };
62346     } catch (Dali::DaliException e) {
62347       {
62348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62349       };
62350     } catch (...) {
62351       {
62352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62353       };
62354     }
62355   }
62356
62357 }
62358
62359
62360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62362
62363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62364   {
62365     try {
62366       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62367     } catch (std::out_of_range& e) {
62368       {
62369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62370       };
62371     } catch (std::exception& e) {
62372       {
62373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62374       };
62375     } catch (Dali::DaliException e) {
62376       {
62377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62378       };
62379     } catch (...) {
62380       {
62381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62382       };
62383     }
62384   }
62385
62386 }
62387
62388
62389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62391
62392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62393   {
62394     try {
62395       (arg1)->OnKeyInputFocusLost();
62396     } catch (std::out_of_range& e) {
62397       {
62398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62399       };
62400     } catch (std::exception& e) {
62401       {
62402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62403       };
62404     } catch (Dali::DaliException e) {
62405       {
62406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62407       };
62408     } catch (...) {
62409       {
62410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62411       };
62412     }
62413   }
62414
62415 }
62416
62417
62418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62420
62421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62422   {
62423     try {
62424       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62425     } catch (std::out_of_range& e) {
62426       {
62427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62428       };
62429     } catch (std::exception& e) {
62430       {
62431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62432       };
62433     } catch (Dali::DaliException e) {
62434       {
62435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62436       };
62437     } catch (...) {
62438       {
62439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62440       };
62441     }
62442   }
62443
62444 }
62445
62446
62447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62448   void * jresult ;
62449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62450   Dali::Actor arg2 ;
62451   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62452   bool arg4 ;
62453   Dali::Actor *argp2 ;
62454   Dali::Actor result;
62455
62456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62457   argp2 = (Dali::Actor *)jarg2;
62458   if (!argp2) {
62459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62460     return 0;
62461   }
62462   arg2 = *argp2;
62463   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62464   arg4 = jarg4 ? true : false;
62465   {
62466     try {
62467       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62468     } catch (std::out_of_range& e) {
62469       {
62470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62471       };
62472     } catch (std::exception& e) {
62473       {
62474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62475       };
62476     } catch (Dali::DaliException e) {
62477       {
62478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62479       };
62480     } catch (...) {
62481       {
62482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62483       };
62484     }
62485   }
62486
62487   jresult = new Dali::Actor((const Dali::Actor &)result);
62488   return jresult;
62489 }
62490
62491
62492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62493   void * jresult ;
62494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62495   Dali::Actor arg2 ;
62496   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62497   bool arg4 ;
62498   Dali::Actor *argp2 ;
62499   Dali::Actor result;
62500
62501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62502   argp2 = (Dali::Actor *)jarg2;
62503   if (!argp2) {
62504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62505     return 0;
62506   }
62507   arg2 = *argp2;
62508   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62509   arg4 = jarg4 ? true : false;
62510   {
62511     try {
62512       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62513     } catch (std::out_of_range& e) {
62514       {
62515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62516       };
62517     } catch (std::exception& e) {
62518       {
62519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62520       };
62521     } catch (Dali::DaliException e) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62524       };
62525     } catch (...) {
62526       {
62527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62528       };
62529     }
62530   }
62531
62532   jresult = new Dali::Actor((const Dali::Actor &)result);
62533   return jresult;
62534 }
62535
62536
62537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62539   Dali::Actor arg2 ;
62540   Dali::Actor *argp2 ;
62541
62542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62543   argp2 = (Dali::Actor *)jarg2;
62544   if (!argp2) {
62545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62546     return ;
62547   }
62548   arg2 = *argp2;
62549   {
62550     try {
62551       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62552     } catch (std::out_of_range& e) {
62553       {
62554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62555       };
62556     } catch (std::exception& e) {
62557       {
62558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62559       };
62560     } catch (Dali::DaliException e) {
62561       {
62562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62563       };
62564     } catch (...) {
62565       {
62566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62567       };
62568     }
62569   }
62570
62571 }
62572
62573
62574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62576   Dali::Actor arg2 ;
62577   Dali::Actor *argp2 ;
62578
62579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62580   argp2 = (Dali::Actor *)jarg2;
62581   if (!argp2) {
62582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62583     return ;
62584   }
62585   arg2 = *argp2;
62586   {
62587     try {
62588       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62589     } catch (std::out_of_range& e) {
62590       {
62591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62592       };
62593     } catch (std::exception& e) {
62594       {
62595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62596       };
62597     } catch (Dali::DaliException e) {
62598       {
62599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62600       };
62601     } catch (...) {
62602       {
62603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62604       };
62605     }
62606   }
62607
62608 }
62609
62610
62611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62612   unsigned int jresult ;
62613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62614   bool result;
62615
62616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62617   {
62618     try {
62619       result = (bool)(arg1)->OnKeyboardEnter();
62620     } catch (std::out_of_range& e) {
62621       {
62622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62623       };
62624     } catch (std::exception& e) {
62625       {
62626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62627       };
62628     } catch (Dali::DaliException e) {
62629       {
62630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62631       };
62632     } catch (...) {
62633       {
62634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62635       };
62636     }
62637   }
62638
62639   jresult = result;
62640   return jresult;
62641 }
62642
62643
62644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62645   unsigned int jresult ;
62646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62647   bool result;
62648
62649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62650   {
62651     try {
62652       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62653     } catch (std::out_of_range& e) {
62654       {
62655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62656       };
62657     } catch (std::exception& e) {
62658       {
62659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62660       };
62661     } catch (Dali::DaliException e) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62664       };
62665     } catch (...) {
62666       {
62667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62668       };
62669     }
62670   }
62671
62672   jresult = result;
62673   return jresult;
62674 }
62675
62676
62677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62679   Dali::PinchGesture *arg2 = 0 ;
62680
62681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62682   arg2 = (Dali::PinchGesture *)jarg2;
62683   if (!arg2) {
62684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62685     return ;
62686   }
62687   {
62688     try {
62689       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62690     } catch (std::out_of_range& e) {
62691       {
62692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62693       };
62694     } catch (std::exception& e) {
62695       {
62696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62697       };
62698     } catch (Dali::DaliException e) {
62699       {
62700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62701       };
62702     } catch (...) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62705       };
62706     }
62707   }
62708
62709 }
62710
62711
62712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62714   Dali::PinchGesture *arg2 = 0 ;
62715
62716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62717   arg2 = (Dali::PinchGesture *)jarg2;
62718   if (!arg2) {
62719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62720     return ;
62721   }
62722   {
62723     try {
62724       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62725     } catch (std::out_of_range& e) {
62726       {
62727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62728       };
62729     } catch (std::exception& e) {
62730       {
62731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62732       };
62733     } catch (Dali::DaliException e) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62736       };
62737     } catch (...) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62740       };
62741     }
62742   }
62743
62744 }
62745
62746
62747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62749   Dali::PanGesture *arg2 = 0 ;
62750
62751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62752   arg2 = (Dali::PanGesture *)jarg2;
62753   if (!arg2) {
62754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62755     return ;
62756   }
62757   {
62758     try {
62759       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62760     } catch (std::out_of_range& e) {
62761       {
62762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62763       };
62764     } catch (std::exception& e) {
62765       {
62766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62767       };
62768     } catch (Dali::DaliException e) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62771       };
62772     } catch (...) {
62773       {
62774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62775       };
62776     }
62777   }
62778
62779 }
62780
62781
62782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62784   Dali::PanGesture *arg2 = 0 ;
62785
62786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62787   arg2 = (Dali::PanGesture *)jarg2;
62788   if (!arg2) {
62789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62790     return ;
62791   }
62792   {
62793     try {
62794       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62795     } catch (std::out_of_range& e) {
62796       {
62797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62798       };
62799     } catch (std::exception& e) {
62800       {
62801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62802       };
62803     } catch (Dali::DaliException e) {
62804       {
62805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62806       };
62807     } catch (...) {
62808       {
62809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62810       };
62811     }
62812   }
62813
62814 }
62815
62816
62817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62819   Dali::TapGesture *arg2 = 0 ;
62820
62821   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62822   arg2 = (Dali::TapGesture *)jarg2;
62823   if (!arg2) {
62824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62825     return ;
62826   }
62827   {
62828     try {
62829       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62830     } catch (std::out_of_range& e) {
62831       {
62832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62833       };
62834     } catch (std::exception& e) {
62835       {
62836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62837       };
62838     } catch (Dali::DaliException e) {
62839       {
62840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62841       };
62842     } catch (...) {
62843       {
62844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62845       };
62846     }
62847   }
62848
62849 }
62850
62851
62852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62854   Dali::TapGesture *arg2 = 0 ;
62855
62856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62857   arg2 = (Dali::TapGesture *)jarg2;
62858   if (!arg2) {
62859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62860     return ;
62861   }
62862   {
62863     try {
62864       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62865     } catch (std::out_of_range& e) {
62866       {
62867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62868       };
62869     } catch (std::exception& e) {
62870       {
62871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62872       };
62873     } catch (Dali::DaliException e) {
62874       {
62875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62876       };
62877     } catch (...) {
62878       {
62879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62880       };
62881     }
62882   }
62883
62884 }
62885
62886
62887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62889   Dali::LongPressGesture *arg2 = 0 ;
62890
62891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62892   arg2 = (Dali::LongPressGesture *)jarg2;
62893   if (!arg2) {
62894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62895     return ;
62896   }
62897   {
62898     try {
62899       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62900     } catch (std::out_of_range& e) {
62901       {
62902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62903       };
62904     } catch (std::exception& e) {
62905       {
62906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62907       };
62908     } catch (Dali::DaliException e) {
62909       {
62910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62911       };
62912     } catch (...) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62915       };
62916     }
62917   }
62918
62919 }
62920
62921
62922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62924   Dali::LongPressGesture *arg2 = 0 ;
62925
62926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62927   arg2 = (Dali::LongPressGesture *)jarg2;
62928   if (!arg2) {
62929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62930     return ;
62931   }
62932   {
62933     try {
62934       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62950       };
62951     }
62952   }
62953
62954 }
62955
62956
62957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62958   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62959   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62960   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62961
62962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62963   arg2 = (Dali::SlotObserver *)jarg2;
62964   arg3 = (Dali::CallbackBase *)jarg3;
62965   {
62966     try {
62967       (arg1)->SignalConnected(arg2,arg3);
62968     } catch (std::out_of_range& e) {
62969       {
62970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62971       };
62972     } catch (std::exception& e) {
62973       {
62974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62975       };
62976     } catch (Dali::DaliException e) {
62977       {
62978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62979       };
62980     } catch (...) {
62981       {
62982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62983       };
62984     }
62985   }
62986
62987 }
62988
62989
62990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62992   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62993   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62994
62995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62996   arg2 = (Dali::SlotObserver *)jarg2;
62997   arg3 = (Dali::CallbackBase *)jarg3;
62998   {
62999     try {
63000       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63001     } catch (std::out_of_range& e) {
63002       {
63003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63004       };
63005     } catch (std::exception& e) {
63006       {
63007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63008       };
63009     } catch (Dali::DaliException e) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63012       };
63013     } catch (...) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63016       };
63017     }
63018   }
63019
63020 }
63021
63022
63023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63025   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63026   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63027
63028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63029   arg2 = (Dali::SlotObserver *)jarg2;
63030   arg3 = (Dali::CallbackBase *)jarg3;
63031   {
63032     try {
63033       (arg1)->SignalDisconnected(arg2,arg3);
63034     } catch (std::out_of_range& e) {
63035       {
63036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63037       };
63038     } catch (std::exception& e) {
63039       {
63040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63041       };
63042     } catch (Dali::DaliException e) {
63043       {
63044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63045       };
63046     } catch (...) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63049       };
63050     }
63051   }
63052
63053 }
63054
63055
63056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63058   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63059   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63060
63061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63062   arg2 = (Dali::SlotObserver *)jarg2;
63063   arg3 = (Dali::CallbackBase *)jarg3;
63064   {
63065     try {
63066       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63067     } catch (std::out_of_range& e) {
63068       {
63069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63070       };
63071     } catch (std::exception& e) {
63072       {
63073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63074       };
63075     } catch (Dali::DaliException e) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63082       };
63083     }
63084   }
63085
63086 }
63087
63088 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) {
63089   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63090   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63091   if (director) {
63092     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);
63093   }
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63098   void * jresult ;
63099   Dali::Toolkit::Control *arg1 = 0 ;
63100   Dali::Toolkit::Internal::Control *result = 0 ;
63101
63102   arg1 = (Dali::Toolkit::Control *)jarg1;
63103   if (!arg1) {
63104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63105     return 0;
63106   }
63107   {
63108     try {
63109       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63110     } catch (std::out_of_range& e) {
63111       {
63112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63113       };
63114     } catch (std::exception& e) {
63115       {
63116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63117       };
63118     } catch (Dali::DaliException e) {
63119       {
63120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63125       };
63126     }
63127   }
63128
63129   jresult = (void *)result;
63130   return jresult;
63131 }
63132
63133
63134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63135   int jresult ;
63136   int result;
63137
63138   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63139   jresult = (int)result;
63140   return jresult;
63141 }
63142
63143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63144   int jresult ;
63145   int result;
63146
63147   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63148   jresult = (int)result;
63149   return jresult;
63150 }
63151
63152
63153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63154   int jresult ;
63155   int result;
63156
63157   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63158   jresult = (int)result;
63159   return jresult;
63160 }
63161
63162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
63163   int jresult ;
63164   int result;
63165
63166   result = (int)Dali::Toolkit::Control::Property::MARGIN;
63167   jresult = (int)result;
63168   return jresult;
63169 }
63170
63171
63172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
63173   int jresult ;
63174   int result;
63175
63176   result = (int)Dali::Toolkit::Control::Property::PADDING;
63177   jresult = (int)result;
63178   return jresult;
63179 }
63180
63181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63182   int jresult ;
63183   int result;
63184
63185   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63186   jresult = (int)result;
63187   return jresult;
63188 }
63189
63190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63191   void * jresult ;
63192   Dali::Toolkit::Control::Property *result = 0 ;
63193
63194   {
63195     try {
63196       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63197     } catch (std::out_of_range& e) {
63198       {
63199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63200       };
63201     } catch (std::exception& e) {
63202       {
63203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63204       };
63205     } catch (Dali::DaliException e) {
63206       {
63207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63208       };
63209     } catch (...) {
63210       {
63211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63212       };
63213     }
63214   }
63215
63216   jresult = (void *)result;
63217   return jresult;
63218 }
63219
63220
63221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63222   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63223
63224   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63225   {
63226     try {
63227       delete arg1;
63228     } catch (std::out_of_range& e) {
63229       {
63230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63231       };
63232     } catch (std::exception& e) {
63233       {
63234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63235       };
63236     } catch (Dali::DaliException e) {
63237       {
63238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63239       };
63240     } catch (...) {
63241       {
63242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63243       };
63244     }
63245   }
63246
63247 }
63248
63249
63250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63251   void * jresult ;
63252   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63253
63254   {
63255     try {
63256       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63257     } catch (std::out_of_range& e) {
63258       {
63259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63260       };
63261     } catch (std::exception& e) {
63262       {
63263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63264       };
63265     } catch (Dali::DaliException e) {
63266       {
63267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63268       };
63269     } catch (...) {
63270       {
63271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63272       };
63273     }
63274   }
63275
63276   jresult = (void *)result;
63277   return jresult;
63278 }
63279
63280
63281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63282   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63283
63284   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63285   {
63286     try {
63287       delete arg1;
63288     } catch (std::out_of_range& e) {
63289       {
63290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63291       };
63292     } catch (std::exception& e) {
63293       {
63294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63295       };
63296     } catch (Dali::DaliException e) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63299       };
63300     } catch (...) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63303       };
63304     }
63305   }
63306
63307 }
63308
63309
63310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63311   void * jresult ;
63312   Dali::Toolkit::Control result;
63313
63314   {
63315     try {
63316       result = Dali::Toolkit::Control::New();
63317     } catch (std::out_of_range& e) {
63318       {
63319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63320       };
63321     } catch (std::exception& e) {
63322       {
63323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63324       };
63325     } catch (Dali::DaliException e) {
63326       {
63327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63328       };
63329     } catch (...) {
63330       {
63331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63332       };
63333     }
63334   }
63335
63336   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63337   return jresult;
63338 }
63339
63340
63341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63342   void * jresult ;
63343   Dali::Toolkit::Control *result = 0 ;
63344
63345   {
63346     try {
63347       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63348     } catch (std::out_of_range& e) {
63349       {
63350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (std::exception& e) {
63353       {
63354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63355       };
63356     } catch (Dali::DaliException e) {
63357       {
63358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63359       };
63360     } catch (...) {
63361       {
63362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63363       };
63364     }
63365   }
63366
63367   jresult = (void *)result;
63368   return jresult;
63369 }
63370
63371
63372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63373   void * jresult ;
63374   Dali::Toolkit::Control *arg1 = 0 ;
63375   Dali::Toolkit::Control *result = 0 ;
63376
63377   arg1 = (Dali::Toolkit::Control *)jarg1;
63378   if (!arg1) {
63379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63380     return 0;
63381   }
63382   {
63383     try {
63384       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63385     } catch (std::out_of_range& e) {
63386       {
63387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63388       };
63389     } catch (std::exception& e) {
63390       {
63391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63392       };
63393     } catch (Dali::DaliException e) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63396       };
63397     } catch (...) {
63398       {
63399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63400       };
63401     }
63402   }
63403
63404   jresult = (void *)result;
63405   return jresult;
63406 }
63407
63408
63409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63410   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63411
63412   arg1 = (Dali::Toolkit::Control *)jarg1;
63413   {
63414     try {
63415       delete arg1;
63416     } catch (std::out_of_range& e) {
63417       {
63418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63419       };
63420     } catch (std::exception& e) {
63421       {
63422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63423       };
63424     } catch (Dali::DaliException e) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63427       };
63428     } catch (...) {
63429       {
63430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63431       };
63432     }
63433   }
63434
63435 }
63436
63437
63438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63439   void * jresult ;
63440   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63441   Dali::Toolkit::Control *arg2 = 0 ;
63442   Dali::Toolkit::Control *result = 0 ;
63443
63444   arg1 = (Dali::Toolkit::Control *)jarg1;
63445   arg2 = (Dali::Toolkit::Control *)jarg2;
63446   if (!arg2) {
63447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63448     return 0;
63449   }
63450   {
63451     try {
63452       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63453     } catch (std::out_of_range& e) {
63454       {
63455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63456       };
63457     } catch (std::exception& e) {
63458       {
63459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63460       };
63461     } catch (Dali::DaliException e) {
63462       {
63463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63464       };
63465     } catch (...) {
63466       {
63467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63468       };
63469     }
63470   }
63471
63472   jresult = (void *)result;
63473   return jresult;
63474 }
63475
63476
63477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63478   void * jresult ;
63479   Dali::BaseHandle arg1 ;
63480   Dali::BaseHandle *argp1 ;
63481   Dali::Toolkit::Control result;
63482
63483   argp1 = (Dali::BaseHandle *)jarg1;
63484   if (!argp1) {
63485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63486     return 0;
63487   }
63488   arg1 = *argp1;
63489   {
63490     try {
63491       result = Dali::Toolkit::Control::DownCast(arg1);
63492     } catch (std::out_of_range& e) {
63493       {
63494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63495       };
63496     } catch (std::exception& e) {
63497       {
63498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63499       };
63500     } catch (Dali::DaliException e) {
63501       {
63502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63503       };
63504     } catch (...) {
63505       {
63506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63507       };
63508     }
63509   }
63510
63511   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63512   return jresult;
63513 }
63514
63515
63516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63517   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63518
63519   arg1 = (Dali::Toolkit::Control *)jarg1;
63520   {
63521     try {
63522       (arg1)->SetKeyInputFocus();
63523     } catch (std::out_of_range& e) {
63524       {
63525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63526       };
63527     } catch (std::exception& e) {
63528       {
63529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63530       };
63531     } catch (Dali::DaliException e) {
63532       {
63533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63534       };
63535     } catch (...) {
63536       {
63537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63538       };
63539     }
63540   }
63541
63542 }
63543
63544
63545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63546   unsigned int jresult ;
63547   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63548   bool result;
63549
63550   arg1 = (Dali::Toolkit::Control *)jarg1;
63551   {
63552     try {
63553       result = (bool)(arg1)->HasKeyInputFocus();
63554     } catch (std::out_of_range& e) {
63555       {
63556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63557       };
63558     } catch (std::exception& e) {
63559       {
63560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63561       };
63562     } catch (Dali::DaliException e) {
63563       {
63564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63565       };
63566     } catch (...) {
63567       {
63568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63569       };
63570     }
63571   }
63572
63573   jresult = result;
63574   return jresult;
63575 }
63576
63577
63578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63579   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63580
63581   arg1 = (Dali::Toolkit::Control *)jarg1;
63582   {
63583     try {
63584       (arg1)->ClearKeyInputFocus();
63585     } catch (std::out_of_range& e) {
63586       {
63587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63588       };
63589     } catch (std::exception& e) {
63590       {
63591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63592       };
63593     } catch (Dali::DaliException e) {
63594       {
63595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63596       };
63597     } catch (...) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63600       };
63601     }
63602   }
63603
63604 }
63605
63606
63607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63608   void * jresult ;
63609   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63610   Dali::PinchGestureDetector result;
63611
63612   arg1 = (Dali::Toolkit::Control *)jarg1;
63613   {
63614     try {
63615       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63616     } catch (std::out_of_range& e) {
63617       {
63618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63619       };
63620     } catch (std::exception& e) {
63621       {
63622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (Dali::DaliException e) {
63625       {
63626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63627       };
63628     } catch (...) {
63629       {
63630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63631       };
63632     }
63633   }
63634
63635   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63636   return jresult;
63637 }
63638
63639
63640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63641   void * jresult ;
63642   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63643   Dali::PanGestureDetector result;
63644
63645   arg1 = (Dali::Toolkit::Control *)jarg1;
63646   {
63647     try {
63648       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63649     } catch (std::out_of_range& e) {
63650       {
63651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63652       };
63653     } catch (std::exception& e) {
63654       {
63655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63656       };
63657     } catch (Dali::DaliException e) {
63658       {
63659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63660       };
63661     } catch (...) {
63662       {
63663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63664       };
63665     }
63666   }
63667
63668   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63669   return jresult;
63670 }
63671
63672
63673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63674   void * jresult ;
63675   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63676   Dali::TapGestureDetector result;
63677
63678   arg1 = (Dali::Toolkit::Control *)jarg1;
63679   {
63680     try {
63681       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63682     } catch (std::out_of_range& e) {
63683       {
63684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63685       };
63686     } catch (std::exception& e) {
63687       {
63688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63689       };
63690     } catch (Dali::DaliException e) {
63691       {
63692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63693       };
63694     } catch (...) {
63695       {
63696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63697       };
63698     }
63699   }
63700
63701   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63702   return jresult;
63703 }
63704
63705
63706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63707   void * jresult ;
63708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63709   Dali::LongPressGestureDetector result;
63710
63711   arg1 = (Dali::Toolkit::Control *)jarg1;
63712   {
63713     try {
63714       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63715     } catch (std::out_of_range& e) {
63716       {
63717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63718       };
63719     } catch (std::exception& e) {
63720       {
63721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63722       };
63723     } catch (Dali::DaliException e) {
63724       {
63725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63726       };
63727     } catch (...) {
63728       {
63729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63730       };
63731     }
63732   }
63733
63734   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63735   return jresult;
63736 }
63737
63738
63739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63740   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63741   std::string *arg2 = 0 ;
63742
63743   arg1 = (Dali::Toolkit::Control *)jarg1;
63744   if (!jarg2) {
63745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63746     return ;
63747   }
63748   std::string arg2_str(jarg2);
63749   arg2 = &arg2_str;
63750   {
63751     try {
63752       (arg1)->SetStyleName((std::string const &)*arg2);
63753     } catch (std::out_of_range& e) {
63754       {
63755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63756       };
63757     } catch (std::exception& e) {
63758       {
63759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63760       };
63761     } catch (Dali::DaliException e) {
63762       {
63763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63764       };
63765     } catch (...) {
63766       {
63767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63768       };
63769     }
63770   }
63771
63772
63773   //argout typemap for const std::string&
63774
63775 }
63776
63777
63778 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63779   char * jresult ;
63780   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63781   std::string *result = 0 ;
63782
63783   arg1 = (Dali::Toolkit::Control *)jarg1;
63784   {
63785     try {
63786       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63787     } catch (std::out_of_range& e) {
63788       {
63789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63790       };
63791     } catch (std::exception& e) {
63792       {
63793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63794       };
63795     } catch (Dali::DaliException e) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63798       };
63799     } catch (...) {
63800       {
63801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63802       };
63803     }
63804   }
63805
63806   jresult = SWIG_csharp_string_callback(result->c_str());
63807   return jresult;
63808 }
63809
63810
63811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63812   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63813   Dali::Vector4 *arg2 = 0 ;
63814
63815   arg1 = (Dali::Toolkit::Control *)jarg1;
63816   arg2 = (Dali::Vector4 *)jarg2;
63817   if (!arg2) {
63818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63819     return ;
63820   }
63821   {
63822     try {
63823       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63824     } catch (std::out_of_range& e) {
63825       {
63826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63827       };
63828     } catch (std::exception& e) {
63829       {
63830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63831       };
63832     } catch (Dali::DaliException e) {
63833       {
63834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63835       };
63836     } catch (...) {
63837       {
63838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63839       };
63840     }
63841   }
63842
63843 }
63844
63845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63846   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63847
63848   arg1 = (Dali::Toolkit::Control *)jarg1;
63849   {
63850     try {
63851       (arg1)->ClearBackground();
63852     } catch (std::out_of_range& e) {
63853       {
63854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63855       };
63856     } catch (std::exception& e) {
63857       {
63858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63859       };
63860     } catch (Dali::DaliException e) {
63861       {
63862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63863       };
63864     } catch (...) {
63865       {
63866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63867       };
63868     }
63869   }
63870
63871 }
63872
63873
63874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63875   void * jresult ;
63876   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63877   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63878
63879   arg1 = (Dali::Toolkit::Control *)jarg1;
63880   {
63881     try {
63882       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63883     } catch (std::out_of_range& e) {
63884       {
63885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63886       };
63887     } catch (std::exception& e) {
63888       {
63889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63890       };
63891     } catch (Dali::DaliException e) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63894       };
63895     } catch (...) {
63896       {
63897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63898       };
63899     }
63900   }
63901
63902   jresult = (void *)result;
63903   return jresult;
63904 }
63905
63906
63907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63908   void * jresult ;
63909   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63910   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63911
63912   arg1 = (Dali::Toolkit::Control *)jarg1;
63913   {
63914     try {
63915       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63916     } catch (std::out_of_range& e) {
63917       {
63918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63919       };
63920     } catch (std::exception& e) {
63921       {
63922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63923       };
63924     } catch (Dali::DaliException e) {
63925       {
63926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63927       };
63928     } catch (...) {
63929       {
63930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63931       };
63932     }
63933   }
63934
63935   jresult = (void *)result;
63936   return jresult;
63937 }
63938
63939
63940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63941   void * jresult ;
63942   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63943   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63944
63945   arg1 = (Dali::Toolkit::Control *)jarg1;
63946   {
63947     try {
63948       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63956       };
63957     } catch (Dali::DaliException e) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63960       };
63961     } catch (...) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63964       };
63965     }
63966   }
63967
63968   jresult = (void *)result;
63969   return jresult;
63970 }
63971
63972
63973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63974   void * jresult ;
63975   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63976   Dali::Toolkit::Control *result = 0 ;
63977
63978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63979   if (!arg1) {
63980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63981     return 0;
63982   }
63983   {
63984     try {
63985       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63986     } catch (std::out_of_range& e) {
63987       {
63988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63989       };
63990     } catch (std::exception& e) {
63991       {
63992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63993       };
63994     } catch (Dali::DaliException e) {
63995       {
63996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63997       };
63998     } catch (...) {
63999       {
64000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64001       };
64002     }
64003   }
64004
64005   jresult = (void *)result;
64006   return jresult;
64007 }
64008
64009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
64010 {
64011   int jresult;
64012   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64013   arg1 = (Dali::Toolkit::Control *)jarg1;
64014
64015   if (!arg1) {
64016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64017     return 0;
64018   }
64019
64020   Dali::Property::Index arg2 = 0 ;
64021   arg2 = (Dali::Property::Index)jarg2;
64022
64023   Toolkit::Visual::ResourceStatus result;
64024   {
64025     try {
64026       result = arg1->GetVisualResourceStatus(arg2);
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64038       };
64039     }
64040   }
64041   jresult = (int)(result);
64042   return jresult;
64043 }
64044
64045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64046 {
64047   void * jresult;
64048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64049   arg1 = (Dali::Toolkit::Control *)jarg1;
64050
64051   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64052
64053   Dali::Toolkit::TransitionData *arg2 = 0 ;
64054   Dali::Animation result;
64055
64056   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64057   if (!arg2) {
64058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64059     return 0;
64060   }
64061   {
64062     try {
64063       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64064     } catch (std::out_of_range& e) {
64065       {
64066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64067       };
64068     } catch (std::exception& e) {
64069       {
64070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64071       };
64072     } catch (Dali::DaliException e) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64075       };
64076     } catch (...) {
64077       {
64078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64079       };
64080     }
64081   }
64082
64083   jresult = new Dali::Animation((const Dali::Animation &)result);
64084   return jresult;
64085 }
64086
64087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
64088 {
64089   Dali::Toolkit::Control arg1;
64090   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
64091
64092   if (!argp1) {
64093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64094   }
64095   arg1 = *argp1;
64096
64097   Dali::Property::Index arg2 = 0 ;
64098   arg2 = (Dali::Property::Index)jarg2;
64099
64100   Dali::Property::Index arg3 = 0 ;
64101   arg3 = (Dali::Property::Index)jarg3;
64102
64103   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
64104
64105   {
64106     try {
64107       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
64108     } catch (std::out_of_range& e) {
64109       {
64110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64111       };
64112     } catch (std::exception& e) {
64113       {
64114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64115       };
64116     } catch (...) {
64117       {
64118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64119       };
64120     }
64121   }
64122
64123
64124 }
64125
64126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64127   void * jresult ;
64128   Dali::Toolkit::Control *arg1 = 0 ;
64129   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
64130
64131   arg1 = (Dali::Toolkit::Control *)jarg1;
64132   if (!arg1) {
64133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64134     return 0;
64135   }
64136   {
64137     try {
64138       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
64139     } catch (std::out_of_range& e) {
64140       {
64141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64142       };
64143     } catch (std::exception& e) {
64144       {
64145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64146       };
64147     } catch (Dali::DaliException e) {
64148       {
64149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64150       };
64151     } catch (...) {
64152       {
64153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64154       };
64155     }
64156   }
64157
64158   jresult = (void *)result;
64159   return jresult;
64160 }
64161
64162
64163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64164   unsigned int jresult ;
64165   Dali::Toolkit::Control *arg1 = 0 ;
64166   bool result;
64167
64168   arg1 = (Dali::Toolkit::Control *)jarg1;
64169   if (!arg1) {
64170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64171     return 0;
64172   }
64173   {
64174     try {
64175       result = (bool)arg1->IsResourceReady();
64176     } catch (std::out_of_range& e) {
64177       {
64178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64179       };
64180     } catch (std::exception& e) {
64181       {
64182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64183       };
64184     } catch (Dali::DaliException e) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64187       };
64188     } catch (...) {
64189       {
64190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64191       };
64192     }
64193   }
64194
64195   jresult = result;
64196   return jresult;
64197 }
64198
64199
64200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64201   void * jresult ;
64202   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64203
64204   {
64205     try {
64206       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64207     } catch (std::out_of_range& e) {
64208       {
64209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64210       };
64211     } catch (std::exception& e) {
64212       {
64213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64214       };
64215     } catch (Dali::DaliException e) {
64216       {
64217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64218       };
64219     } catch (...) {
64220       {
64221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64222       };
64223     }
64224   }
64225
64226   jresult = (void *)result;
64227   return jresult;
64228 }
64229
64230
64231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64232   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64233
64234   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64235   {
64236     try {
64237       delete arg1;
64238     } catch (std::out_of_range& e) {
64239       {
64240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64241       };
64242     } catch (std::exception& e) {
64243       {
64244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64245       };
64246     } catch (Dali::DaliException e) {
64247       {
64248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64249       };
64250     } catch (...) {
64251       {
64252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64253       };
64254     }
64255   }
64256
64257 }
64258
64259
64260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64261   void * jresult ;
64262   Dali::Toolkit::KeyInputFocusManager result;
64263
64264   {
64265     try {
64266       result = Dali::Toolkit::KeyInputFocusManager::Get();
64267     } catch (std::out_of_range& e) {
64268       {
64269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64270       };
64271     } catch (std::exception& e) {
64272       {
64273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64274       };
64275     } catch (Dali::DaliException e) {
64276       {
64277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64278       };
64279     } catch (...) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64282       };
64283     }
64284   }
64285
64286   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64287   return jresult;
64288 }
64289
64290
64291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64292   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64293   Dali::Toolkit::Control arg2 ;
64294   Dali::Toolkit::Control *argp2 ;
64295
64296   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64297   argp2 = (Dali::Toolkit::Control *)jarg2;
64298   if (!argp2) {
64299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64300     return ;
64301   }
64302   arg2 = *argp2;
64303   {
64304     try {
64305       (arg1)->SetFocus(arg2);
64306     } catch (std::out_of_range& e) {
64307       {
64308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64309       };
64310     } catch (std::exception& e) {
64311       {
64312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64313       };
64314     } catch (Dali::DaliException e) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64317       };
64318     } catch (...) {
64319       {
64320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64321       };
64322     }
64323   }
64324
64325 }
64326
64327
64328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64329   void * jresult ;
64330   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64331   Dali::Toolkit::Control result;
64332
64333   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64334   {
64335     try {
64336       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64337     } catch (std::out_of_range& e) {
64338       {
64339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64340       };
64341     } catch (std::exception& e) {
64342       {
64343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64344       };
64345     } catch (Dali::DaliException e) {
64346       {
64347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64352       };
64353     }
64354   }
64355
64356   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64357   return jresult;
64358 }
64359
64360
64361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64362   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64363   Dali::Toolkit::Control arg2 ;
64364   Dali::Toolkit::Control *argp2 ;
64365
64366   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64367   argp2 = (Dali::Toolkit::Control *)jarg2;
64368   if (!argp2) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64370     return ;
64371   }
64372   arg2 = *argp2;
64373   {
64374     try {
64375       (arg1)->RemoveFocus(arg2);
64376     } catch (std::out_of_range& e) {
64377       {
64378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64379       };
64380     } catch (std::exception& e) {
64381       {
64382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64383       };
64384     } catch (Dali::DaliException e) {
64385       {
64386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64387       };
64388     } catch (...) {
64389       {
64390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64391       };
64392     }
64393   }
64394
64395 }
64396
64397
64398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64399   void * jresult ;
64400   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64401   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64402
64403   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64404   {
64405     try {
64406       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
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_new_Alignment_Padding__SWIG_0() {
64432   void * jresult ;
64433   Dali::Toolkit::Alignment::Padding *result = 0 ;
64434
64435   {
64436     try {
64437       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64438     } catch (std::out_of_range& e) {
64439       {
64440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64441       };
64442     } catch (std::exception& e) {
64443       {
64444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64445       };
64446     } catch (Dali::DaliException e) {
64447       {
64448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64449       };
64450     } catch (...) {
64451       {
64452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64453       };
64454     }
64455   }
64456
64457   jresult = (void *)result;
64458   return jresult;
64459 }
64460
64461
64462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64463   void * jresult ;
64464   float arg1 ;
64465   float arg2 ;
64466   float arg3 ;
64467   float arg4 ;
64468   Dali::Toolkit::Alignment::Padding *result = 0 ;
64469
64470   arg1 = (float)jarg1;
64471   arg2 = (float)jarg2;
64472   arg3 = (float)jarg3;
64473   arg4 = (float)jarg4;
64474   {
64475     try {
64476       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64477     } catch (std::out_of_range& e) {
64478       {
64479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (std::exception& e) {
64482       {
64483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (Dali::DaliException e) {
64486       {
64487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64488       };
64489     } catch (...) {
64490       {
64491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64492       };
64493     }
64494   }
64495
64496   jresult = (void *)result;
64497   return jresult;
64498 }
64499
64500
64501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64502   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64503   float arg2 ;
64504
64505   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64506   arg2 = (float)jarg2;
64507   if (arg1) (arg1)->left = arg2;
64508 }
64509
64510
64511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64512   float jresult ;
64513   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64514   float result;
64515
64516   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64517   result = (float) ((arg1)->left);
64518   jresult = result;
64519   return jresult;
64520 }
64521
64522
64523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64524   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64525   float arg2 ;
64526
64527   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64528   arg2 = (float)jarg2;
64529   if (arg1) (arg1)->right = arg2;
64530 }
64531
64532
64533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64534   float jresult ;
64535   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64536   float result;
64537
64538   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64539   result = (float) ((arg1)->right);
64540   jresult = result;
64541   return jresult;
64542 }
64543
64544
64545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64546   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64547   float arg2 ;
64548
64549   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64550   arg2 = (float)jarg2;
64551   if (arg1) (arg1)->top = arg2;
64552 }
64553
64554
64555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64556   float jresult ;
64557   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64558   float result;
64559
64560   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64561   result = (float) ((arg1)->top);
64562   jresult = result;
64563   return jresult;
64564 }
64565
64566
64567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64568   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64569   float arg2 ;
64570
64571   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64572   arg2 = (float)jarg2;
64573   if (arg1) (arg1)->bottom = arg2;
64574 }
64575
64576
64577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64578   float jresult ;
64579   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64580   float result;
64581
64582   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64583   result = (float) ((arg1)->bottom);
64584   jresult = result;
64585   return jresult;
64586 }
64587
64588
64589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64590   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64591
64592   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64593   {
64594     try {
64595       delete arg1;
64596     } catch (std::out_of_range& e) {
64597       {
64598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64599       };
64600     } catch (std::exception& e) {
64601       {
64602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64603       };
64604     } catch (Dali::DaliException e) {
64605       {
64606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64607       };
64608     } catch (...) {
64609       {
64610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64611       };
64612     }
64613   }
64614
64615 }
64616
64617
64618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64619   void * jresult ;
64620   Dali::Toolkit::Alignment *result = 0 ;
64621
64622   {
64623     try {
64624       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64625     } catch (std::out_of_range& e) {
64626       {
64627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64628       };
64629     } catch (std::exception& e) {
64630       {
64631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64632       };
64633     } catch (Dali::DaliException e) {
64634       {
64635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64636       };
64637     } catch (...) {
64638       {
64639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64640       };
64641     }
64642   }
64643
64644   jresult = (void *)result;
64645   return jresult;
64646 }
64647
64648
64649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64650   void * jresult ;
64651   Dali::Toolkit::Alignment::Type arg1 ;
64652   Dali::Toolkit::Alignment::Type arg2 ;
64653   Dali::Toolkit::Alignment result;
64654
64655   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64656   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64657   {
64658     try {
64659       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64660     } catch (std::out_of_range& e) {
64661       {
64662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64663       };
64664     } catch (std::exception& e) {
64665       {
64666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64667       };
64668     } catch (Dali::DaliException e) {
64669       {
64670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64671       };
64672     } catch (...) {
64673       {
64674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64675       };
64676     }
64677   }
64678
64679   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64680   return jresult;
64681 }
64682
64683
64684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64685   void * jresult ;
64686   Dali::Toolkit::Alignment::Type arg1 ;
64687   Dali::Toolkit::Alignment result;
64688
64689   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64690   {
64691     try {
64692       result = Dali::Toolkit::Alignment::New(arg1);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64700       };
64701     } catch (Dali::DaliException e) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64704       };
64705     } catch (...) {
64706       {
64707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64708       };
64709     }
64710   }
64711
64712   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64713   return jresult;
64714 }
64715
64716
64717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64718   void * jresult ;
64719   Dali::Toolkit::Alignment result;
64720
64721   {
64722     try {
64723       result = Dali::Toolkit::Alignment::New();
64724     } catch (std::out_of_range& e) {
64725       {
64726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64727       };
64728     } catch (std::exception& e) {
64729       {
64730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64731       };
64732     } catch (Dali::DaliException e) {
64733       {
64734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64735       };
64736     } catch (...) {
64737       {
64738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64739       };
64740     }
64741   }
64742
64743   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64744   return jresult;
64745 }
64746
64747
64748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64749   void * jresult ;
64750   Dali::Toolkit::Alignment *arg1 = 0 ;
64751   Dali::Toolkit::Alignment *result = 0 ;
64752
64753   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64754   if (!arg1) {
64755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64756     return 0;
64757   }
64758   {
64759     try {
64760       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64761     } catch (std::out_of_range& e) {
64762       {
64763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64764       };
64765     } catch (std::exception& e) {
64766       {
64767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64768       };
64769     } catch (Dali::DaliException e) {
64770       {
64771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64772       };
64773     } catch (...) {
64774       {
64775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64776       };
64777     }
64778   }
64779
64780   jresult = (void *)result;
64781   return jresult;
64782 }
64783
64784
64785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64786   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64787
64788   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64789   {
64790     try {
64791       delete arg1;
64792     } catch (std::out_of_range& e) {
64793       {
64794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64795       };
64796     } catch (std::exception& e) {
64797       {
64798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64799       };
64800     } catch (Dali::DaliException e) {
64801       {
64802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64803       };
64804     } catch (...) {
64805       {
64806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64807       };
64808     }
64809   }
64810
64811 }
64812
64813
64814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64815   void * jresult ;
64816   Dali::BaseHandle arg1 ;
64817   Dali::BaseHandle *argp1 ;
64818   Dali::Toolkit::Alignment result;
64819
64820   argp1 = (Dali::BaseHandle *)jarg1;
64821   if (!argp1) {
64822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64823     return 0;
64824   }
64825   arg1 = *argp1;
64826   {
64827     try {
64828       result = Dali::Toolkit::Alignment::DownCast(arg1);
64829     } catch (std::out_of_range& e) {
64830       {
64831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64832       };
64833     } catch (std::exception& e) {
64834       {
64835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64836       };
64837     } catch (Dali::DaliException e) {
64838       {
64839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64840       };
64841     } catch (...) {
64842       {
64843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64844       };
64845     }
64846   }
64847
64848   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64849   return jresult;
64850 }
64851
64852
64853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64854   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64855   Dali::Toolkit::Alignment::Type arg2 ;
64856
64857   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64858   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64859   {
64860     try {
64861       (arg1)->SetAlignmentType(arg2);
64862     } catch (std::out_of_range& e) {
64863       {
64864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64865       };
64866     } catch (std::exception& e) {
64867       {
64868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64869       };
64870     } catch (Dali::DaliException e) {
64871       {
64872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64873       };
64874     } catch (...) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64877       };
64878     }
64879   }
64880
64881 }
64882
64883
64884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64885   int jresult ;
64886   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64887   Dali::Toolkit::Alignment::Type result;
64888
64889   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64890   {
64891     try {
64892       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64893     } catch (std::out_of_range& e) {
64894       {
64895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64896       };
64897     } catch (std::exception& e) {
64898       {
64899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64900       };
64901     } catch (Dali::DaliException e) {
64902       {
64903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64904       };
64905     } catch (...) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64908       };
64909     }
64910   }
64911
64912   jresult = (int)result;
64913   return jresult;
64914 }
64915
64916
64917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64918   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64919   Dali::Toolkit::Alignment::Scaling arg2 ;
64920
64921   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64922   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64923   {
64924     try {
64925       (arg1)->SetScaling(arg2);
64926     } catch (std::out_of_range& e) {
64927       {
64928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64929       };
64930     } catch (std::exception& e) {
64931       {
64932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64933       };
64934     } catch (Dali::DaliException e) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64937       };
64938     } catch (...) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64941       };
64942     }
64943   }
64944
64945 }
64946
64947
64948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64949   int jresult ;
64950   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64951   Dali::Toolkit::Alignment::Scaling result;
64952
64953   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64954   {
64955     try {
64956       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64957     } catch (std::out_of_range& e) {
64958       {
64959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (std::exception& e) {
64962       {
64963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64964       };
64965     } catch (Dali::DaliException e) {
64966       {
64967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64968       };
64969     } catch (...) {
64970       {
64971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64972       };
64973     }
64974   }
64975
64976   jresult = (int)result;
64977   return jresult;
64978 }
64979
64980
64981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64982   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64983   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64984
64985   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64986   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64987   if (!arg2) {
64988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64989     return ;
64990   }
64991   {
64992     try {
64993       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64994     } catch (std::out_of_range& e) {
64995       {
64996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64997       };
64998     } catch (std::exception& e) {
64999       {
65000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65001       };
65002     } catch (Dali::DaliException e) {
65003       {
65004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65005       };
65006     } catch (...) {
65007       {
65008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65009       };
65010     }
65011   }
65012
65013 }
65014
65015
65016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
65017   void * jresult ;
65018   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65019   Dali::Toolkit::Alignment::Padding *result = 0 ;
65020
65021   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65022   {
65023     try {
65024       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
65025     } catch (std::out_of_range& e) {
65026       {
65027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65028       };
65029     } catch (std::exception& e) {
65030       {
65031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65032       };
65033     } catch (Dali::DaliException e) {
65034       {
65035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65036       };
65037     } catch (...) {
65038       {
65039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65040       };
65041     }
65042   }
65043
65044   jresult = (void *)result;
65045   return jresult;
65046 }
65047
65048
65049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
65050   void * jresult ;
65051   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65052   Dali::Toolkit::Alignment *arg2 = 0 ;
65053   Dali::Toolkit::Alignment *result = 0 ;
65054
65055   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65056   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65057   if (!arg2) {
65058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65059     return 0;
65060   }
65061   {
65062     try {
65063       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65064     } catch (std::out_of_range& e) {
65065       {
65066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65067       };
65068     } catch (std::exception& e) {
65069       {
65070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65071       };
65072     } catch (Dali::DaliException e) {
65073       {
65074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65075       };
65076     } catch (...) {
65077       {
65078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65079       };
65080     }
65081   }
65082
65083   jresult = (void *)result;
65084   return jresult;
65085 }
65086
65087
65088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65089   int jresult ;
65090   int result;
65091
65092   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65093   jresult = (int)result;
65094   return jresult;
65095 }
65096
65097
65098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65099   int jresult ;
65100   int result;
65101
65102   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65103   jresult = (int)result;
65104   return jresult;
65105 }
65106
65107
65108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65109   int jresult ;
65110   int result;
65111
65112   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65113   jresult = (int)result;
65114   return jresult;
65115 }
65116
65117
65118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65119   int jresult ;
65120   int result;
65121
65122   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65123   jresult = (int)result;
65124   return jresult;
65125 }
65126
65127
65128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65129   int jresult ;
65130   int result;
65131
65132   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65133   jresult = (int)result;
65134   return jresult;
65135 }
65136
65137
65138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65139   int jresult ;
65140   int result;
65141
65142   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65143   jresult = (int)result;
65144   return jresult;
65145 }
65146
65147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65148   int jresult ;
65149   int result;
65150
65151   result = (int)Dali::Toolkit::Button::Property::LABEL;
65152   jresult = (int)result;
65153   return jresult;
65154 }
65155
65156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65157   void * jresult ;
65158   Dali::Toolkit::Button::Property *result = 0 ;
65159
65160   {
65161     try {
65162       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65163     } catch (std::out_of_range& e) {
65164       {
65165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65166       };
65167     } catch (std::exception& e) {
65168       {
65169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65170       };
65171     } catch (Dali::DaliException e) {
65172       {
65173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65174       };
65175     } catch (...) {
65176       {
65177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65178       };
65179     }
65180   }
65181
65182   jresult = (void *)result;
65183   return jresult;
65184 }
65185
65186
65187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65188   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65189
65190   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65191   {
65192     try {
65193       delete arg1;
65194     } catch (std::out_of_range& e) {
65195       {
65196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65197       };
65198     } catch (std::exception& e) {
65199       {
65200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65201       };
65202     } catch (Dali::DaliException e) {
65203       {
65204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65205       };
65206     } catch (...) {
65207       {
65208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65209       };
65210     }
65211   }
65212
65213 }
65214
65215
65216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65217   void * jresult ;
65218   Dali::Toolkit::Button *result = 0 ;
65219
65220   {
65221     try {
65222       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65223     } catch (std::out_of_range& e) {
65224       {
65225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (std::exception& e) {
65228       {
65229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (Dali::DaliException e) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65234       };
65235     } catch (...) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65238       };
65239     }
65240   }
65241
65242   jresult = (void *)result;
65243   return jresult;
65244 }
65245
65246
65247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65248   void * jresult ;
65249   Dali::Toolkit::Button *arg1 = 0 ;
65250   Dali::Toolkit::Button *result = 0 ;
65251
65252   arg1 = (Dali::Toolkit::Button *)jarg1;
65253   if (!arg1) {
65254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65255     return 0;
65256   }
65257   {
65258     try {
65259       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65260     } catch (std::out_of_range& e) {
65261       {
65262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65263       };
65264     } catch (std::exception& e) {
65265       {
65266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65267       };
65268     } catch (Dali::DaliException e) {
65269       {
65270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65271       };
65272     } catch (...) {
65273       {
65274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65275       };
65276     }
65277   }
65278
65279   jresult = (void *)result;
65280   return jresult;
65281 }
65282
65283
65284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65285   void * jresult ;
65286   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65287   Dali::Toolkit::Button *arg2 = 0 ;
65288   Dali::Toolkit::Button *result = 0 ;
65289
65290   arg1 = (Dali::Toolkit::Button *)jarg1;
65291   arg2 = (Dali::Toolkit::Button *)jarg2;
65292   if (!arg2) {
65293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65294     return 0;
65295   }
65296   {
65297     try {
65298       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65299     } catch (std::out_of_range& e) {
65300       {
65301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (std::exception& e) {
65304       {
65305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65306       };
65307     } catch (Dali::DaliException e) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65310       };
65311     } catch (...) {
65312       {
65313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65314       };
65315     }
65316   }
65317
65318   jresult = (void *)result;
65319   return jresult;
65320 }
65321
65322
65323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65324   void * jresult ;
65325   Dali::BaseHandle arg1 ;
65326   Dali::BaseHandle *argp1 ;
65327   Dali::Toolkit::Button result;
65328
65329   argp1 = (Dali::BaseHandle *)jarg1;
65330   if (!argp1) {
65331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65332     return 0;
65333   }
65334   arg1 = *argp1;
65335   {
65336     try {
65337       result = Dali::Toolkit::Button::DownCast(arg1);
65338     } catch (std::out_of_range& e) {
65339       {
65340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65341       };
65342     } catch (std::exception& e) {
65343       {
65344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65345       };
65346     } catch (Dali::DaliException e) {
65347       {
65348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65349       };
65350     } catch (...) {
65351       {
65352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65353       };
65354     }
65355   }
65356
65357   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65358   return jresult;
65359 }
65360
65361
65362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65363   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65364
65365   arg1 = (Dali::Toolkit::Button *)jarg1;
65366   {
65367     try {
65368       delete arg1;
65369     } catch (std::out_of_range& e) {
65370       {
65371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65372       };
65373     } catch (std::exception& e) {
65374       {
65375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65376       };
65377     } catch (Dali::DaliException e) {
65378       {
65379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65380       };
65381     } catch (...) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65384       };
65385     }
65386   }
65387
65388 }
65389
65390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65391   void * jresult ;
65392   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65393   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65394
65395   arg1 = (Dali::Toolkit::Button *)jarg1;
65396   {
65397     try {
65398       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65399     } catch (std::out_of_range& e) {
65400       {
65401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65402       };
65403     } catch (std::exception& e) {
65404       {
65405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (Dali::DaliException e) {
65408       {
65409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65410       };
65411     } catch (...) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65414       };
65415     }
65416   }
65417
65418   jresult = (void *)result;
65419   return jresult;
65420 }
65421
65422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65423   void * jresult ;
65424   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65425   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65426
65427   arg1 = (Dali::Toolkit::Button *)jarg1;
65428   {
65429     try {
65430       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65438       };
65439     } catch (Dali::DaliException e) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65442       };
65443     } catch (...) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65446       };
65447     }
65448   }
65449
65450   jresult = (void *)result;
65451   return jresult;
65452 }
65453
65454
65455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65456   void * jresult ;
65457   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65458   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65459
65460   arg1 = (Dali::Toolkit::Button *)jarg1;
65461   {
65462     try {
65463       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65464     } catch (std::out_of_range& e) {
65465       {
65466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65467       };
65468     } catch (std::exception& e) {
65469       {
65470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65471       };
65472     } catch (Dali::DaliException e) {
65473       {
65474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65475       };
65476     } catch (...) {
65477       {
65478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65479       };
65480     }
65481   }
65482
65483   jresult = (void *)result;
65484   return jresult;
65485 }
65486
65487
65488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65489   void * jresult ;
65490   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65491   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65492
65493   arg1 = (Dali::Toolkit::Button *)jarg1;
65494   {
65495     try {
65496       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
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_new_CheckBoxButton__SWIG_0() {
65522   void * jresult ;
65523   Dali::Toolkit::CheckBoxButton *result = 0 ;
65524
65525   {
65526     try {
65527       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65528     } catch (std::out_of_range& e) {
65529       {
65530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65531       };
65532     } catch (std::exception& e) {
65533       {
65534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65535       };
65536     } catch (Dali::DaliException e) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65539       };
65540     } catch (...) {
65541       {
65542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65543       };
65544     }
65545   }
65546
65547   jresult = (void *)result;
65548   return jresult;
65549 }
65550
65551
65552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65553   void * jresult ;
65554   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65555   Dali::Toolkit::CheckBoxButton *result = 0 ;
65556
65557   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65558   if (!arg1) {
65559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65560     return 0;
65561   }
65562   {
65563     try {
65564       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65565     } catch (std::out_of_range& e) {
65566       {
65567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65568       };
65569     } catch (std::exception& e) {
65570       {
65571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65572       };
65573     } catch (Dali::DaliException e) {
65574       {
65575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65576       };
65577     } catch (...) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65580       };
65581     }
65582   }
65583
65584   jresult = (void *)result;
65585   return jresult;
65586 }
65587
65588
65589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65590   void * jresult ;
65591   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65592   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65593   Dali::Toolkit::CheckBoxButton *result = 0 ;
65594
65595   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65596   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65597   if (!arg2) {
65598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65599     return 0;
65600   }
65601   {
65602     try {
65603       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65604     } catch (std::out_of_range& e) {
65605       {
65606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65607       };
65608     } catch (std::exception& e) {
65609       {
65610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65611       };
65612     } catch (Dali::DaliException e) {
65613       {
65614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65615       };
65616     } catch (...) {
65617       {
65618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65619       };
65620     }
65621   }
65622
65623   jresult = (void *)result;
65624   return jresult;
65625 }
65626
65627
65628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65629   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65630
65631   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65632   {
65633     try {
65634       delete arg1;
65635     } catch (std::out_of_range& e) {
65636       {
65637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65638       };
65639     } catch (std::exception& e) {
65640       {
65641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65642       };
65643     } catch (Dali::DaliException e) {
65644       {
65645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65646       };
65647     } catch (...) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65650       };
65651     }
65652   }
65653
65654 }
65655
65656
65657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65658   void * jresult ;
65659   Dali::Toolkit::CheckBoxButton result;
65660
65661   {
65662     try {
65663       result = Dali::Toolkit::CheckBoxButton::New();
65664     } catch (std::out_of_range& e) {
65665       {
65666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65667       };
65668     } catch (std::exception& e) {
65669       {
65670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65671       };
65672     } catch (Dali::DaliException e) {
65673       {
65674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65675       };
65676     } catch (...) {
65677       {
65678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65679       };
65680     }
65681   }
65682
65683   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65684   return jresult;
65685 }
65686
65687
65688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65689   void * jresult ;
65690   Dali::BaseHandle arg1 ;
65691   Dali::BaseHandle *argp1 ;
65692   Dali::Toolkit::CheckBoxButton result;
65693
65694   argp1 = (Dali::BaseHandle *)jarg1;
65695   if (!argp1) {
65696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65697     return 0;
65698   }
65699   arg1 = *argp1;
65700   {
65701     try {
65702       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (Dali::DaliException e) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65714       };
65715     } catch (...) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65718       };
65719     }
65720   }
65721
65722   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65723   return jresult;
65724 }
65725
65726
65727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65728   int jresult ;
65729   int result;
65730
65731   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65732   jresult = (int)result;
65733   return jresult;
65734 }
65735
65736
65737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65738   int jresult ;
65739   int result;
65740
65741   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65742   jresult = (int)result;
65743   return jresult;
65744 }
65745
65746
65747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65748   void * jresult ;
65749   Dali::Toolkit::PushButton::Property *result = 0 ;
65750
65751   {
65752     try {
65753       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65754     } catch (std::out_of_range& e) {
65755       {
65756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65757       };
65758     } catch (std::exception& e) {
65759       {
65760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65761       };
65762     } catch (Dali::DaliException e) {
65763       {
65764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65765       };
65766     } catch (...) {
65767       {
65768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65769       };
65770     }
65771   }
65772
65773   jresult = (void *)result;
65774   return jresult;
65775 }
65776
65777
65778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65779   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65780
65781   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65782   {
65783     try {
65784       delete arg1;
65785     } catch (std::out_of_range& e) {
65786       {
65787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65788       };
65789     } catch (std::exception& e) {
65790       {
65791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65792       };
65793     } catch (Dali::DaliException e) {
65794       {
65795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65796       };
65797     } catch (...) {
65798       {
65799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65800       };
65801     }
65802   }
65803
65804 }
65805
65806
65807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65808   void * jresult ;
65809   Dali::Toolkit::PushButton *result = 0 ;
65810
65811   {
65812     try {
65813       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65814     } catch (std::out_of_range& e) {
65815       {
65816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (std::exception& e) {
65819       {
65820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65821       };
65822     } catch (Dali::DaliException e) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65825       };
65826     } catch (...) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65829       };
65830     }
65831   }
65832
65833   jresult = (void *)result;
65834   return jresult;
65835 }
65836
65837
65838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65839   void * jresult ;
65840   Dali::Toolkit::PushButton *arg1 = 0 ;
65841   Dali::Toolkit::PushButton *result = 0 ;
65842
65843   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65844   if (!arg1) {
65845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65846     return 0;
65847   }
65848   {
65849     try {
65850       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65851     } catch (std::out_of_range& e) {
65852       {
65853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65854       };
65855     } catch (std::exception& e) {
65856       {
65857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (Dali::DaliException e) {
65860       {
65861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65862       };
65863     } catch (...) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65866       };
65867     }
65868   }
65869
65870   jresult = (void *)result;
65871   return jresult;
65872 }
65873
65874
65875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65876   void * jresult ;
65877   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65878   Dali::Toolkit::PushButton *arg2 = 0 ;
65879   Dali::Toolkit::PushButton *result = 0 ;
65880
65881   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65882   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65883   if (!arg2) {
65884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65885     return 0;
65886   }
65887   {
65888     try {
65889       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65890     } catch (std::out_of_range& e) {
65891       {
65892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65893       };
65894     } catch (std::exception& e) {
65895       {
65896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65897       };
65898     } catch (Dali::DaliException e) {
65899       {
65900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65901       };
65902     } catch (...) {
65903       {
65904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65905       };
65906     }
65907   }
65908
65909   jresult = (void *)result;
65910   return jresult;
65911 }
65912
65913
65914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65915   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65916
65917   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65918   {
65919     try {
65920       delete arg1;
65921     } catch (std::out_of_range& e) {
65922       {
65923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65924       };
65925     } catch (std::exception& e) {
65926       {
65927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65928       };
65929     } catch (Dali::DaliException e) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65932       };
65933     } catch (...) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65936       };
65937     }
65938   }
65939
65940 }
65941
65942
65943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65944   void * jresult ;
65945   Dali::Toolkit::PushButton result;
65946
65947   {
65948     try {
65949       result = Dali::Toolkit::PushButton::New();
65950     } catch (std::out_of_range& e) {
65951       {
65952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65953       };
65954     } catch (std::exception& e) {
65955       {
65956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65957       };
65958     } catch (Dali::DaliException e) {
65959       {
65960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65961       };
65962     } catch (...) {
65963       {
65964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65965       };
65966     }
65967   }
65968
65969   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65970   return jresult;
65971 }
65972
65973
65974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65975   void * jresult ;
65976   Dali::BaseHandle arg1 ;
65977   Dali::BaseHandle *argp1 ;
65978   Dali::Toolkit::PushButton result;
65979
65980   argp1 = (Dali::BaseHandle *)jarg1;
65981   if (!argp1) {
65982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65983     return 0;
65984   }
65985   arg1 = *argp1;
65986   {
65987     try {
65988       result = Dali::Toolkit::PushButton::DownCast(arg1);
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65996       };
65997     } catch (Dali::DaliException e) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66000       };
66001     } catch (...) {
66002       {
66003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66004       };
66005     }
66006   }
66007
66008   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66009   return jresult;
66010 }
66011
66012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66013   void * jresult ;
66014   Dali::Toolkit::RadioButton *result = 0 ;
66015
66016   {
66017     try {
66018       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66019     } catch (std::out_of_range& e) {
66020       {
66021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66022       };
66023     } catch (std::exception& e) {
66024       {
66025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66026       };
66027     } catch (Dali::DaliException e) {
66028       {
66029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66030       };
66031     } catch (...) {
66032       {
66033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66034       };
66035     }
66036   }
66037
66038   jresult = (void *)result;
66039   return jresult;
66040 }
66041
66042
66043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66044   void * jresult ;
66045   Dali::Toolkit::RadioButton *arg1 = 0 ;
66046   Dali::Toolkit::RadioButton *result = 0 ;
66047
66048   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66049   if (!arg1) {
66050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66051     return 0;
66052   }
66053   {
66054     try {
66055       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66056     } catch (std::out_of_range& e) {
66057       {
66058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66059       };
66060     } catch (std::exception& e) {
66061       {
66062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66063       };
66064     } catch (Dali::DaliException e) {
66065       {
66066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66067       };
66068     } catch (...) {
66069       {
66070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66071       };
66072     }
66073   }
66074
66075   jresult = (void *)result;
66076   return jresult;
66077 }
66078
66079
66080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66081   void * jresult ;
66082   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66083   Dali::Toolkit::RadioButton *arg2 = 0 ;
66084   Dali::Toolkit::RadioButton *result = 0 ;
66085
66086   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66087   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66088   if (!arg2) {
66089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66090     return 0;
66091   }
66092   {
66093     try {
66094       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66095     } catch (std::out_of_range& e) {
66096       {
66097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66098       };
66099     } catch (std::exception& e) {
66100       {
66101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66102       };
66103     } catch (Dali::DaliException e) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66106       };
66107     } catch (...) {
66108       {
66109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66110       };
66111     }
66112   }
66113
66114   jresult = (void *)result;
66115   return jresult;
66116 }
66117
66118
66119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66120   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66121
66122   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66123   {
66124     try {
66125       delete arg1;
66126     } catch (std::out_of_range& e) {
66127       {
66128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66129       };
66130     } catch (std::exception& e) {
66131       {
66132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66133       };
66134     } catch (Dali::DaliException e) {
66135       {
66136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66137       };
66138     } catch (...) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66141       };
66142     }
66143   }
66144
66145 }
66146
66147
66148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66149   void * jresult ;
66150   Dali::Toolkit::RadioButton result;
66151
66152   {
66153     try {
66154       result = Dali::Toolkit::RadioButton::New();
66155     } catch (std::out_of_range& e) {
66156       {
66157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (std::exception& e) {
66160       {
66161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66162       };
66163     } catch (Dali::DaliException e) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66166       };
66167     } catch (...) {
66168       {
66169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66170       };
66171     }
66172   }
66173
66174   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66175   return jresult;
66176 }
66177
66178
66179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66180   void * jresult ;
66181   std::string *arg1 = 0 ;
66182   Dali::Toolkit::RadioButton result;
66183
66184   if (!jarg1) {
66185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66186     return 0;
66187   }
66188   std::string arg1_str(jarg1);
66189   arg1 = &arg1_str;
66190   {
66191     try {
66192       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66193     } catch (std::out_of_range& e) {
66194       {
66195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66196       };
66197     } catch (std::exception& e) {
66198       {
66199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66200       };
66201     } catch (Dali::DaliException e) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66204       };
66205     } catch (...) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66208       };
66209     }
66210   }
66211
66212   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66213
66214   //argout typemap for const std::string&
66215
66216   return jresult;
66217 }
66218
66219
66220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66221   void * jresult ;
66222   Dali::BaseHandle arg1 ;
66223   Dali::BaseHandle *argp1 ;
66224   Dali::Toolkit::RadioButton result;
66225
66226   argp1 = (Dali::BaseHandle *)jarg1;
66227   if (!argp1) {
66228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66229     return 0;
66230   }
66231   arg1 = *argp1;
66232   {
66233     try {
66234       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66235     } catch (std::out_of_range& e) {
66236       {
66237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66238       };
66239     } catch (std::exception& e) {
66240       {
66241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66242       };
66243     } catch (Dali::DaliException e) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66250       };
66251     }
66252   }
66253
66254   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66255   return jresult;
66256 }
66257
66258
66259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66260   int jresult ;
66261   int result;
66262
66263   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66264   jresult = (int)result;
66265   return jresult;
66266 }
66267
66268
66269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66270   int jresult ;
66271   int result;
66272
66273   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66274   jresult = (int)result;
66275   return jresult;
66276 }
66277
66278
66279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66280   int jresult ;
66281   int result;
66282
66283   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66284   jresult = (int)result;
66285   return jresult;
66286 }
66287
66288
66289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66290   int jresult ;
66291   int result;
66292
66293   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66294   jresult = (int)result;
66295   return jresult;
66296 }
66297
66298
66299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66300   int jresult ;
66301   int result;
66302
66303   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66304   jresult = (int)result;
66305   return jresult;
66306 }
66307
66308
66309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66310   int jresult ;
66311   int result;
66312
66313   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66314   jresult = (int)result;
66315   return jresult;
66316 }
66317
66318
66319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66320   void * jresult ;
66321   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66322
66323   {
66324     try {
66325       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66326     } catch (std::out_of_range& e) {
66327       {
66328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66329       };
66330     } catch (std::exception& e) {
66331       {
66332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66333       };
66334     } catch (Dali::DaliException e) {
66335       {
66336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66337       };
66338     } catch (...) {
66339       {
66340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66341       };
66342     }
66343   }
66344
66345   jresult = (void *)result;
66346   return jresult;
66347 }
66348
66349
66350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66351   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66352
66353   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66354   {
66355     try {
66356       delete arg1;
66357     } catch (std::out_of_range& e) {
66358       {
66359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66360       };
66361     } catch (std::exception& e) {
66362       {
66363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66364       };
66365     } catch (Dali::DaliException e) {
66366       {
66367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66368       };
66369     } catch (...) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66372       };
66373     }
66374   }
66375
66376 }
66377
66378
66379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66380   int jresult ;
66381   int result;
66382
66383   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66384   jresult = (int)result;
66385   return jresult;
66386 }
66387
66388
66389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66390   int jresult ;
66391   int result;
66392
66393   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66394   jresult = (int)result;
66395   return jresult;
66396 }
66397
66398
66399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66400   int jresult ;
66401   int result;
66402
66403   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66404   jresult = (int)result;
66405   return jresult;
66406 }
66407
66408
66409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66410   void * jresult ;
66411   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66412
66413   {
66414     try {
66415       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66416     } catch (std::out_of_range& e) {
66417       {
66418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66419       };
66420     } catch (std::exception& e) {
66421       {
66422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66423       };
66424     } catch (Dali::DaliException e) {
66425       {
66426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66427       };
66428     } catch (...) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66431       };
66432     }
66433   }
66434
66435   jresult = (void *)result;
66436   return jresult;
66437 }
66438
66439
66440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66441   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66442
66443   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66444   {
66445     try {
66446       delete arg1;
66447     } catch (std::out_of_range& e) {
66448       {
66449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66450       };
66451     } catch (std::exception& e) {
66452       {
66453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66454       };
66455     } catch (Dali::DaliException e) {
66456       {
66457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66462       };
66463     }
66464   }
66465
66466 }
66467
66468
66469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66470   void * jresult ;
66471   Dali::Toolkit::FlexContainer *result = 0 ;
66472
66473   {
66474     try {
66475       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66476     } catch (std::out_of_range& e) {
66477       {
66478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66479       };
66480     } catch (std::exception& e) {
66481       {
66482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66483       };
66484     } catch (Dali::DaliException e) {
66485       {
66486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66487       };
66488     } catch (...) {
66489       {
66490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66491       };
66492     }
66493   }
66494
66495   jresult = (void *)result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66501   void * jresult ;
66502   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66503   Dali::Toolkit::FlexContainer *result = 0 ;
66504
66505   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66506   if (!arg1) {
66507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66508     return 0;
66509   }
66510   {
66511     try {
66512       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66513     } catch (std::out_of_range& e) {
66514       {
66515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66516       };
66517     } catch (std::exception& e) {
66518       {
66519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66520       };
66521     } catch (Dali::DaliException e) {
66522       {
66523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66524       };
66525     } catch (...) {
66526       {
66527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66528       };
66529     }
66530   }
66531
66532   jresult = (void *)result;
66533   return jresult;
66534 }
66535
66536
66537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66538   void * jresult ;
66539   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66540   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66541   Dali::Toolkit::FlexContainer *result = 0 ;
66542
66543   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66544   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66545   if (!arg2) {
66546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66547     return 0;
66548   }
66549   {
66550     try {
66551       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66552     } catch (std::out_of_range& e) {
66553       {
66554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66555       };
66556     } catch (std::exception& e) {
66557       {
66558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66559       };
66560     } catch (Dali::DaliException e) {
66561       {
66562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66563       };
66564     } catch (...) {
66565       {
66566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66567       };
66568     }
66569   }
66570
66571   jresult = (void *)result;
66572   return jresult;
66573 }
66574
66575
66576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66577   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66578
66579   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66580   {
66581     try {
66582       delete arg1;
66583     } catch (std::out_of_range& e) {
66584       {
66585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66586       };
66587     } catch (std::exception& e) {
66588       {
66589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66590       };
66591     } catch (Dali::DaliException e) {
66592       {
66593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66594       };
66595     } catch (...) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66598       };
66599     }
66600   }
66601
66602 }
66603
66604
66605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66606   void * jresult ;
66607   Dali::Toolkit::FlexContainer result;
66608
66609   {
66610     try {
66611       result = Dali::Toolkit::FlexContainer::New();
66612     } catch (std::out_of_range& e) {
66613       {
66614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66615       };
66616     } catch (std::exception& e) {
66617       {
66618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66619       };
66620     } catch (Dali::DaliException e) {
66621       {
66622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66623       };
66624     } catch (...) {
66625       {
66626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66627       };
66628     }
66629   }
66630
66631   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66632   return jresult;
66633 }
66634
66635
66636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66637   void * jresult ;
66638   Dali::BaseHandle arg1 ;
66639   Dali::BaseHandle *argp1 ;
66640   Dali::Toolkit::FlexContainer result;
66641
66642   argp1 = (Dali::BaseHandle *)jarg1;
66643   if (!argp1) {
66644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66645     return 0;
66646   }
66647   arg1 = *argp1;
66648   {
66649     try {
66650       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66651     } catch (std::out_of_range& e) {
66652       {
66653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66654       };
66655     } catch (std::exception& e) {
66656       {
66657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66658       };
66659     } catch (Dali::DaliException e) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66662       };
66663     } catch (...) {
66664       {
66665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66666       };
66667     }
66668   }
66669
66670   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66671   return jresult;
66672 }
66673
66674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66675   int jresult ;
66676   int result;
66677
66678   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66679   jresult = (int)result;
66680   return jresult;
66681 }
66682
66683
66684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66685   int jresult ;
66686   int result;
66687
66688   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66689   jresult = (int)result;
66690   return jresult;
66691 }
66692
66693
66694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66695   int jresult ;
66696   int result;
66697
66698   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66699   jresult = (int)result;
66700   return jresult;
66701 }
66702
66703
66704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66705   void * jresult ;
66706   Dali::Toolkit::ImageView::Property *result = 0 ;
66707
66708   {
66709     try {
66710       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66718       };
66719     } catch (Dali::DaliException e) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66722       };
66723     } catch (...) {
66724       {
66725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66726       };
66727     }
66728   }
66729
66730   jresult = (void *)result;
66731   return jresult;
66732 }
66733
66734
66735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66736   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66737
66738   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66739   {
66740     try {
66741       delete arg1;
66742     } catch (std::out_of_range& e) {
66743       {
66744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66745       };
66746     } catch (std::exception& e) {
66747       {
66748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66749       };
66750     } catch (Dali::DaliException e) {
66751       {
66752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66753       };
66754     } catch (...) {
66755       {
66756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66757       };
66758     }
66759   }
66760
66761 }
66762
66763
66764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66765   void * jresult ;
66766   Dali::Toolkit::ImageView *result = 0 ;
66767
66768   {
66769     try {
66770       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66771     } catch (std::out_of_range& e) {
66772       {
66773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66774       };
66775     } catch (std::exception& e) {
66776       {
66777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66778       };
66779     } catch (Dali::DaliException e) {
66780       {
66781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66782       };
66783     } catch (...) {
66784       {
66785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66786       };
66787     }
66788   }
66789
66790   jresult = (void *)result;
66791   return jresult;
66792 }
66793
66794
66795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66796   void * jresult ;
66797   Dali::Toolkit::ImageView result;
66798
66799   {
66800     try {
66801       result = Dali::Toolkit::ImageView::New();
66802     } catch (std::out_of_range& e) {
66803       {
66804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66805       };
66806     } catch (std::exception& e) {
66807       {
66808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66809       };
66810     } catch (Dali::DaliException e) {
66811       {
66812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66813       };
66814     } catch (...) {
66815       {
66816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66817       };
66818     }
66819   }
66820
66821   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66822   return jresult;
66823 }
66824
66825
66826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66827   void * jresult ;
66828   std::string *arg1 = 0 ;
66829   Dali::Toolkit::ImageView result;
66830
66831   if (!jarg1) {
66832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66833     return 0;
66834   }
66835   std::string arg1_str(jarg1);
66836   arg1 = &arg1_str;
66837   {
66838     try {
66839       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66840     } catch (std::out_of_range& e) {
66841       {
66842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66843       };
66844     } catch (std::exception& e) {
66845       {
66846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66847       };
66848     } catch (Dali::DaliException e) {
66849       {
66850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66851       };
66852     } catch (...) {
66853       {
66854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66855       };
66856     }
66857   }
66858
66859   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66860
66861   //argout typemap for const std::string&
66862
66863   return jresult;
66864 }
66865
66866
66867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66868   void * jresult ;
66869   std::string *arg1 = 0 ;
66870   Dali::ImageDimensions arg2 ;
66871   Dali::ImageDimensions *argp2 ;
66872   Dali::Toolkit::ImageView result;
66873
66874   if (!jarg1) {
66875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66876     return 0;
66877   }
66878   std::string arg1_str(jarg1);
66879   arg1 = &arg1_str;
66880   argp2 = (Dali::ImageDimensions *)jarg2;
66881   if (!argp2) {
66882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66883     return 0;
66884   }
66885   arg2 = *argp2;
66886   {
66887     try {
66888       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66889     } catch (std::out_of_range& e) {
66890       {
66891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (std::exception& e) {
66894       {
66895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66896       };
66897     } catch (Dali::DaliException e) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66904       };
66905     }
66906   }
66907
66908   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66909
66910   //argout typemap for const std::string&
66911
66912   return jresult;
66913 }
66914
66915
66916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66917   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66918
66919   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66920   {
66921     try {
66922       delete arg1;
66923     } catch (std::out_of_range& e) {
66924       {
66925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (std::exception& e) {
66928       {
66929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66930       };
66931     } catch (Dali::DaliException e) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66934       };
66935     } catch (...) {
66936       {
66937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66938       };
66939     }
66940   }
66941
66942 }
66943
66944
66945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66946   void * jresult ;
66947   Dali::Toolkit::ImageView *arg1 = 0 ;
66948   Dali::Toolkit::ImageView *result = 0 ;
66949
66950   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66951   if (!arg1) {
66952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66953     return 0;
66954   }
66955   {
66956     try {
66957       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66958     } catch (std::out_of_range& e) {
66959       {
66960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66961       };
66962     } catch (std::exception& e) {
66963       {
66964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66965       };
66966     } catch (Dali::DaliException e) {
66967       {
66968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66969       };
66970     } catch (...) {
66971       {
66972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66973       };
66974     }
66975   }
66976
66977   jresult = (void *)result;
66978   return jresult;
66979 }
66980
66981
66982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66983   void * jresult ;
66984   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66985   Dali::Toolkit::ImageView *arg2 = 0 ;
66986   Dali::Toolkit::ImageView *result = 0 ;
66987
66988   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66989   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66990   if (!arg2) {
66991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66992     return 0;
66993   }
66994   {
66995     try {
66996       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66997     } catch (std::out_of_range& e) {
66998       {
66999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67000       };
67001     } catch (std::exception& e) {
67002       {
67003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67004       };
67005     } catch (Dali::DaliException e) {
67006       {
67007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67008       };
67009     } catch (...) {
67010       {
67011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67012       };
67013     }
67014   }
67015
67016   jresult = (void *)result;
67017   return jresult;
67018 }
67019
67020
67021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67022   void * jresult ;
67023   Dali::BaseHandle arg1 ;
67024   Dali::BaseHandle *argp1 ;
67025   Dali::Toolkit::ImageView result;
67026
67027   argp1 = (Dali::BaseHandle *)jarg1;
67028   if (!argp1) {
67029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67030     return 0;
67031   }
67032   arg1 = *argp1;
67033   {
67034     try {
67035       result = Dali::Toolkit::ImageView::DownCast(arg1);
67036     } catch (std::out_of_range& e) {
67037       {
67038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (std::exception& e) {
67041       {
67042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (Dali::DaliException e) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67047       };
67048     } catch (...) {
67049       {
67050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67051       };
67052     }
67053   }
67054
67055   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67061   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67062   std::string *arg2 = 0 ;
67063
67064   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67065   if (!jarg2) {
67066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67067     return ;
67068   }
67069   std::string arg2_str(jarg2);
67070   arg2 = &arg2_str;
67071   {
67072     try {
67073       (arg1)->SetImage((std::string const &)*arg2);
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67081       };
67082     } catch (Dali::DaliException e) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67085       };
67086     } catch (...) {
67087       {
67088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67089       };
67090     }
67091   }
67092
67093
67094   //argout typemap for const std::string&
67095
67096 }
67097
67098
67099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67100   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67101   std::string *arg2 = 0 ;
67102   Dali::ImageDimensions arg3 ;
67103   Dali::ImageDimensions *argp3 ;
67104
67105   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67106   if (!jarg2) {
67107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67108     return ;
67109   }
67110   std::string arg2_str(jarg2);
67111   arg2 = &arg2_str;
67112   argp3 = (Dali::ImageDimensions *)jarg3;
67113   if (!argp3) {
67114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67115     return ;
67116   }
67117   arg3 = *argp3;
67118   {
67119     try {
67120       (arg1)->SetImage((std::string const &)*arg2,arg3);
67121     } catch (std::out_of_range& e) {
67122       {
67123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67124       };
67125     } catch (std::exception& e) {
67126       {
67127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67128       };
67129     } catch (Dali::DaliException e) {
67130       {
67131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67132       };
67133     } catch (...) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67136       };
67137     }
67138   }
67139
67140
67141   //argout typemap for const std::string&
67142
67143 }
67144
67145
67146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67147   int jresult ;
67148   int result;
67149
67150   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67151   jresult = (int)result;
67152   return jresult;
67153 }
67154
67155
67156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67157   int jresult ;
67158   int result;
67159
67160   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67161   jresult = (int)result;
67162   return jresult;
67163 }
67164
67165
67166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67167   int jresult ;
67168   int result;
67169
67170   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67171   jresult = (int)result;
67172   return jresult;
67173 }
67174
67175
67176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67177   int jresult ;
67178   int result;
67179
67180   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67181   jresult = (int)result;
67182   return jresult;
67183 }
67184
67185
67186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67187   int jresult ;
67188   int result;
67189
67190   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67191   jresult = (int)result;
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67197   int jresult ;
67198   int result;
67199
67200   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67201   jresult = (int)result;
67202   return jresult;
67203 }
67204
67205
67206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67207   int jresult ;
67208   int result;
67209
67210   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67211   jresult = (int)result;
67212   return jresult;
67213 }
67214
67215
67216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67217   int jresult ;
67218   int result;
67219
67220   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67221   jresult = (int)result;
67222   return jresult;
67223 }
67224
67225
67226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67227   void * jresult ;
67228   Dali::Toolkit::Model3dView::Property *result = 0 ;
67229
67230   {
67231     try {
67232       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67233     } catch (std::out_of_range& e) {
67234       {
67235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67236       };
67237     } catch (std::exception& e) {
67238       {
67239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67240       };
67241     } catch (Dali::DaliException e) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67244       };
67245     } catch (...) {
67246       {
67247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67248       };
67249     }
67250   }
67251
67252   jresult = (void *)result;
67253   return jresult;
67254 }
67255
67256
67257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67258   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67259
67260   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67261   {
67262     try {
67263       delete arg1;
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67271       };
67272     } catch (Dali::DaliException e) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67275       };
67276     } catch (...) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67279       };
67280     }
67281   }
67282
67283 }
67284
67285
67286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67287   void * jresult ;
67288   Dali::Toolkit::Model3dView result;
67289
67290   {
67291     try {
67292       result = Dali::Toolkit::Model3dView::New();
67293     } catch (std::out_of_range& e) {
67294       {
67295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67296       };
67297     } catch (std::exception& e) {
67298       {
67299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67300       };
67301     } catch (Dali::DaliException e) {
67302       {
67303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67304       };
67305     } catch (...) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67308       };
67309     }
67310   }
67311
67312   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67313   return jresult;
67314 }
67315
67316
67317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67318   void * jresult ;
67319   std::string *arg1 = 0 ;
67320   std::string *arg2 = 0 ;
67321   std::string *arg3 = 0 ;
67322   Dali::Toolkit::Model3dView result;
67323
67324   if (!jarg1) {
67325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67326     return 0;
67327   }
67328   std::string arg1_str(jarg1);
67329   arg1 = &arg1_str;
67330   if (!jarg2) {
67331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67332     return 0;
67333   }
67334   std::string arg2_str(jarg2);
67335   arg2 = &arg2_str;
67336   if (!jarg3) {
67337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67338     return 0;
67339   }
67340   std::string arg3_str(jarg3);
67341   arg3 = &arg3_str;
67342   {
67343     try {
67344       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67345     } catch (std::out_of_range& e) {
67346       {
67347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67348       };
67349     } catch (std::exception& e) {
67350       {
67351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67352       };
67353     } catch (Dali::DaliException e) {
67354       {
67355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67356       };
67357     } catch (...) {
67358       {
67359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67360       };
67361     }
67362   }
67363
67364   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67365
67366   //argout typemap for const std::string&
67367
67368
67369   //argout typemap for const std::string&
67370
67371
67372   //argout typemap for const std::string&
67373
67374   return jresult;
67375 }
67376
67377
67378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67379   void * jresult ;
67380   Dali::Toolkit::Model3dView *result = 0 ;
67381
67382   {
67383     try {
67384       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67385     } catch (std::out_of_range& e) {
67386       {
67387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (std::exception& e) {
67390       {
67391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (Dali::DaliException e) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67400       };
67401     }
67402   }
67403
67404   jresult = (void *)result;
67405   return jresult;
67406 }
67407
67408
67409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67410   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67411
67412   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67413   {
67414     try {
67415       delete arg1;
67416     } catch (std::out_of_range& e) {
67417       {
67418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67419       };
67420     } catch (std::exception& e) {
67421       {
67422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67423       };
67424     } catch (Dali::DaliException e) {
67425       {
67426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67431       };
67432     }
67433   }
67434
67435 }
67436
67437
67438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67439   void * jresult ;
67440   Dali::Toolkit::Model3dView *arg1 = 0 ;
67441   Dali::Toolkit::Model3dView *result = 0 ;
67442
67443   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67444   if (!arg1) {
67445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67446     return 0;
67447   }
67448   {
67449     try {
67450       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67451     } catch (std::out_of_range& e) {
67452       {
67453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67454       };
67455     } catch (std::exception& e) {
67456       {
67457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67458       };
67459     } catch (Dali::DaliException e) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67462       };
67463     } catch (...) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67466       };
67467     }
67468   }
67469
67470   jresult = (void *)result;
67471   return jresult;
67472 }
67473
67474
67475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67476   void * jresult ;
67477   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67478   Dali::Toolkit::Model3dView *arg2 = 0 ;
67479   Dali::Toolkit::Model3dView *result = 0 ;
67480
67481   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67482   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67483   if (!arg2) {
67484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67485     return 0;
67486   }
67487   {
67488     try {
67489       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67490     } catch (std::out_of_range& e) {
67491       {
67492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (std::exception& e) {
67495       {
67496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (Dali::DaliException e) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67501       };
67502     } catch (...) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67505       };
67506     }
67507   }
67508
67509   jresult = (void *)result;
67510   return jresult;
67511 }
67512
67513
67514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67515   void * jresult ;
67516   Dali::BaseHandle arg1 ;
67517   Dali::BaseHandle *argp1 ;
67518   Dali::Toolkit::Model3dView result;
67519
67520   argp1 = (Dali::BaseHandle *)jarg1;
67521   if (!argp1) {
67522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67523     return 0;
67524   }
67525   arg1 = *argp1;
67526   {
67527     try {
67528       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67529     } catch (std::out_of_range& e) {
67530       {
67531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67532       };
67533     } catch (std::exception& e) {
67534       {
67535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67536       };
67537     } catch (Dali::DaliException e) {
67538       {
67539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67540       };
67541     } catch (...) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67544       };
67545     }
67546   }
67547
67548   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67549   return jresult;
67550 }
67551
67552
67553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67554   int jresult ;
67555   int result;
67556
67557   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67558   jresult = (int)result;
67559   return jresult;
67560 }
67561
67562
67563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67564   int jresult ;
67565   int result;
67566
67567   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67568   jresult = (int)result;
67569   return jresult;
67570 }
67571
67572
67573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67574   int jresult ;
67575   int result;
67576
67577   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67578   jresult = (int)result;
67579   return jresult;
67580 }
67581
67582
67583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67584   int jresult ;
67585   int result;
67586
67587   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67588   jresult = (int)result;
67589   return jresult;
67590 }
67591
67592
67593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67594   int jresult ;
67595   int result;
67596
67597   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67598   jresult = (int)result;
67599   return jresult;
67600 }
67601
67602
67603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67604   int jresult ;
67605   int result;
67606
67607   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67608   jresult = (int)result;
67609   return jresult;
67610 }
67611
67612
67613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67614   int jresult ;
67615   int result;
67616
67617   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67618   jresult = (int)result;
67619   return jresult;
67620 }
67621
67622
67623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67624   int jresult ;
67625   int result;
67626
67627   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67628   jresult = (int)result;
67629   return jresult;
67630 }
67631
67632
67633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67634   int jresult ;
67635   int result;
67636
67637   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67638   jresult = (int)result;
67639   return jresult;
67640 }
67641
67642
67643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67644   void * jresult ;
67645   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67646
67647   {
67648     try {
67649       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67650     } catch (std::out_of_range& e) {
67651       {
67652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67653       };
67654     } catch (std::exception& e) {
67655       {
67656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (Dali::DaliException e) {
67659       {
67660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67665       };
67666     }
67667   }
67668
67669   jresult = (void *)result;
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67675   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67676
67677   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67678   {
67679     try {
67680       delete arg1;
67681     } catch (std::out_of_range& e) {
67682       {
67683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67684       };
67685     } catch (std::exception& e) {
67686       {
67687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67688       };
67689     } catch (Dali::DaliException e) {
67690       {
67691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67692       };
67693     } catch (...) {
67694       {
67695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67696       };
67697     }
67698   }
67699
67700 }
67701
67702
67703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67704   void * jresult ;
67705   Dali::Toolkit::ScrollBar *result = 0 ;
67706
67707   {
67708     try {
67709       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67710     } catch (std::out_of_range& e) {
67711       {
67712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67713       };
67714     } catch (std::exception& e) {
67715       {
67716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67717       };
67718     } catch (Dali::DaliException e) {
67719       {
67720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67721       };
67722     } catch (...) {
67723       {
67724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67725       };
67726     }
67727   }
67728
67729   jresult = (void *)result;
67730   return jresult;
67731 }
67732
67733
67734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67735   void * jresult ;
67736   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67737   Dali::Toolkit::ScrollBar *result = 0 ;
67738
67739   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67740   if (!arg1) {
67741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67742     return 0;
67743   }
67744   {
67745     try {
67746       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67747     } catch (std::out_of_range& e) {
67748       {
67749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67750       };
67751     } catch (std::exception& e) {
67752       {
67753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (Dali::DaliException e) {
67756       {
67757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67758       };
67759     } catch (...) {
67760       {
67761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67762       };
67763     }
67764   }
67765
67766   jresult = (void *)result;
67767   return jresult;
67768 }
67769
67770
67771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67772   void * jresult ;
67773   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67774   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67775   Dali::Toolkit::ScrollBar *result = 0 ;
67776
67777   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67778   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67779   if (!arg2) {
67780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67781     return 0;
67782   }
67783   {
67784     try {
67785       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67786     } catch (std::out_of_range& e) {
67787       {
67788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (std::exception& e) {
67791       {
67792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67793       };
67794     } catch (Dali::DaliException e) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67797       };
67798     } catch (...) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67801       };
67802     }
67803   }
67804
67805   jresult = (void *)result;
67806   return jresult;
67807 }
67808
67809
67810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67811   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67812
67813   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67814   {
67815     try {
67816       delete arg1;
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67824       };
67825     } catch (Dali::DaliException e) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67828       };
67829     } catch (...) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67832       };
67833     }
67834   }
67835
67836 }
67837
67838
67839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67840   void * jresult ;
67841   Dali::Toolkit::ScrollBar::Direction arg1 ;
67842   Dali::Toolkit::ScrollBar result;
67843
67844   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67845   {
67846     try {
67847       result = Dali::Toolkit::ScrollBar::New(arg1);
67848     } catch (std::out_of_range& e) {
67849       {
67850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67851       };
67852     } catch (std::exception& e) {
67853       {
67854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67855       };
67856     } catch (Dali::DaliException e) {
67857       {
67858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67859       };
67860     } catch (...) {
67861       {
67862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67863       };
67864     }
67865   }
67866
67867   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67868   return jresult;
67869 }
67870
67871
67872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67873   void * jresult ;
67874   Dali::Toolkit::ScrollBar result;
67875
67876   {
67877     try {
67878       result = Dali::Toolkit::ScrollBar::New();
67879     } catch (std::out_of_range& e) {
67880       {
67881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (std::exception& e) {
67884       {
67885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67886       };
67887     } catch (Dali::DaliException e) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67890       };
67891     } catch (...) {
67892       {
67893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67894       };
67895     }
67896   }
67897
67898   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67899   return jresult;
67900 }
67901
67902
67903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67904   void * jresult ;
67905   Dali::BaseHandle arg1 ;
67906   Dali::BaseHandle *argp1 ;
67907   Dali::Toolkit::ScrollBar result;
67908
67909   argp1 = (Dali::BaseHandle *)jarg1;
67910   if (!argp1) {
67911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67912     return 0;
67913   }
67914   arg1 = *argp1;
67915   {
67916     try {
67917       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (Dali::DaliException e) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67929       };
67930     } catch (...) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67933       };
67934     }
67935   }
67936
67937   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67938   return jresult;
67939 }
67940
67941
67942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67943   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67944   Dali::Handle arg2 ;
67945   Dali::Property::Index arg3 ;
67946   Dali::Property::Index arg4 ;
67947   Dali::Property::Index arg5 ;
67948   Dali::Property::Index arg6 ;
67949   Dali::Handle *argp2 ;
67950
67951   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67952   argp2 = (Dali::Handle *)jarg2;
67953   if (!argp2) {
67954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67955     return ;
67956   }
67957   arg2 = *argp2;
67958   arg3 = (Dali::Property::Index)jarg3;
67959   arg4 = (Dali::Property::Index)jarg4;
67960   arg5 = (Dali::Property::Index)jarg5;
67961   arg6 = (Dali::Property::Index)jarg6;
67962   {
67963     try {
67964       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
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 void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67988   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67989   Dali::Actor arg2 ;
67990   Dali::Actor *argp2 ;
67991
67992   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67993   argp2 = (Dali::Actor *)jarg2;
67994   if (!argp2) {
67995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67996     return ;
67997   }
67998   arg2 = *argp2;
67999   {
68000     try {
68001       (arg1)->SetScrollIndicator(arg2);
68002     } catch (std::out_of_range& e) {
68003       {
68004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68005       };
68006     } catch (std::exception& e) {
68007       {
68008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68009       };
68010     } catch (Dali::DaliException e) {
68011       {
68012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68013       };
68014     } catch (...) {
68015       {
68016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68017       };
68018     }
68019   }
68020
68021 }
68022
68023
68024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68025   void * jresult ;
68026   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68027   Dali::Actor result;
68028
68029   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68030   {
68031     try {
68032       result = (arg1)->GetScrollIndicator();
68033     } catch (std::out_of_range& e) {
68034       {
68035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68036       };
68037     } catch (std::exception& e) {
68038       {
68039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68040       };
68041     } catch (Dali::DaliException e) {
68042       {
68043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68044       };
68045     } catch (...) {
68046       {
68047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68048       };
68049     }
68050   }
68051
68052   jresult = new Dali::Actor((const Dali::Actor &)result);
68053   return jresult;
68054 }
68055
68056
68057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68058   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68059   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68060
68061   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68062   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68063   if (!arg2) {
68064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68065     return ;
68066   }
68067   {
68068     try {
68069       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68070     } catch (std::out_of_range& e) {
68071       {
68072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68073       };
68074     } catch (std::exception& e) {
68075       {
68076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68077       };
68078     } catch (Dali::DaliException e) {
68079       {
68080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68081       };
68082     } catch (...) {
68083       {
68084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68085       };
68086     }
68087   }
68088
68089 }
68090
68091
68092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68093   void * jresult ;
68094   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68095
68096   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68097   {
68098     try {
68099       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()));
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68111       };
68112     }
68113   }
68114   return jresult;
68115 }
68116
68117
68118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68119   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68120   Dali::Toolkit::ScrollBar::Direction arg2 ;
68121
68122   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68123   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68124   {
68125     try {
68126       (arg1)->SetScrollDirection(arg2);
68127     } catch (std::out_of_range& e) {
68128       {
68129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68130       };
68131     } catch (std::exception& e) {
68132       {
68133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68134       };
68135     } catch (Dali::DaliException e) {
68136       {
68137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68138       };
68139     } catch (...) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68142       };
68143     }
68144   }
68145
68146 }
68147
68148
68149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68150   int jresult ;
68151   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68152   Dali::Toolkit::ScrollBar::Direction result;
68153
68154   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68155   {
68156     try {
68157       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68158     } catch (std::out_of_range& e) {
68159       {
68160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68161       };
68162     } catch (std::exception& e) {
68163       {
68164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68165       };
68166     } catch (Dali::DaliException e) {
68167       {
68168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68169       };
68170     } catch (...) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68173       };
68174     }
68175   }
68176
68177   jresult = (int)result;
68178   return jresult;
68179 }
68180
68181
68182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68183   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68184   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68185
68186   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68187   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68188   {
68189     try {
68190       (arg1)->SetIndicatorHeightPolicy(arg2);
68191     } catch (std::out_of_range& e) {
68192       {
68193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68194       };
68195     } catch (std::exception& e) {
68196       {
68197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68198       };
68199     } catch (Dali::DaliException e) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68202       };
68203     } catch (...) {
68204       {
68205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68206       };
68207     }
68208   }
68209
68210 }
68211
68212
68213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68214   int jresult ;
68215   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68216   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68217
68218   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68219   {
68220     try {
68221       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68222     } catch (std::out_of_range& e) {
68223       {
68224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68225       };
68226     } catch (std::exception& e) {
68227       {
68228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (Dali::DaliException e) {
68231       {
68232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68233       };
68234     } catch (...) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68237       };
68238     }
68239   }
68240
68241   jresult = (int)result;
68242   return jresult;
68243 }
68244
68245
68246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68247   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68248   float arg2 ;
68249
68250   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68251   arg2 = (float)jarg2;
68252   {
68253     try {
68254       (arg1)->SetIndicatorFixedHeight(arg2);
68255     } catch (std::out_of_range& e) {
68256       {
68257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68258       };
68259     } catch (std::exception& e) {
68260       {
68261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68262       };
68263     } catch (Dali::DaliException e) {
68264       {
68265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68266       };
68267     } catch (...) {
68268       {
68269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68270       };
68271     }
68272   }
68273
68274 }
68275
68276
68277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68278   float jresult ;
68279   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68280   float result;
68281
68282   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68283   {
68284     try {
68285       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68286     } catch (std::out_of_range& e) {
68287       {
68288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68289       };
68290     } catch (std::exception& e) {
68291       {
68292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68293       };
68294     } catch (Dali::DaliException e) {
68295       {
68296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68297       };
68298     } catch (...) {
68299       {
68300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68301       };
68302     }
68303   }
68304
68305   jresult = result;
68306   return jresult;
68307 }
68308
68309
68310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68311   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68312   float arg2 ;
68313
68314   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68315   arg2 = (float)jarg2;
68316   {
68317     try {
68318       (arg1)->SetIndicatorShowDuration(arg2);
68319     } catch (std::out_of_range& e) {
68320       {
68321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68322       };
68323     } catch (std::exception& e) {
68324       {
68325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68326       };
68327     } catch (Dali::DaliException e) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68330       };
68331     } catch (...) {
68332       {
68333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68334       };
68335     }
68336   }
68337
68338 }
68339
68340
68341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68342   float jresult ;
68343   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68344   float result;
68345
68346   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68347   {
68348     try {
68349       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68350     } catch (std::out_of_range& e) {
68351       {
68352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (std::exception& e) {
68355       {
68356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68357       };
68358     } catch (Dali::DaliException e) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68361       };
68362     } catch (...) {
68363       {
68364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68365       };
68366     }
68367   }
68368
68369   jresult = result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68375   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68376   float arg2 ;
68377
68378   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68379   arg2 = (float)jarg2;
68380   {
68381     try {
68382       (arg1)->SetIndicatorHideDuration(arg2);
68383     } catch (std::out_of_range& e) {
68384       {
68385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68386       };
68387     } catch (std::exception& e) {
68388       {
68389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68390       };
68391     } catch (Dali::DaliException e) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68394       };
68395     } catch (...) {
68396       {
68397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68398       };
68399     }
68400   }
68401
68402 }
68403
68404
68405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68406   float jresult ;
68407   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68408   float result;
68409
68410   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68411   {
68412     try {
68413       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68414     } catch (std::out_of_range& e) {
68415       {
68416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68417       };
68418     } catch (std::exception& e) {
68419       {
68420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68421       };
68422     } catch (Dali::DaliException e) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68425       };
68426     } catch (...) {
68427       {
68428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68429       };
68430     }
68431   }
68432
68433   jresult = result;
68434   return jresult;
68435 }
68436
68437
68438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68439   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68440
68441   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68442   {
68443     try {
68444       (arg1)->ShowIndicator();
68445     } catch (std::out_of_range& e) {
68446       {
68447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68448       };
68449     } catch (std::exception& e) {
68450       {
68451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68452       };
68453     } catch (Dali::DaliException e) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68456       };
68457     } catch (...) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68460       };
68461     }
68462   }
68463
68464 }
68465
68466
68467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68468   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68469
68470   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68471   {
68472     try {
68473       (arg1)->HideIndicator();
68474     } catch (std::out_of_range& e) {
68475       {
68476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68477       };
68478     } catch (std::exception& e) {
68479       {
68480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68481       };
68482     } catch (Dali::DaliException e) {
68483       {
68484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68485       };
68486     } catch (...) {
68487       {
68488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68489       };
68490     }
68491   }
68492
68493 }
68494
68495
68496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68497   void * jresult ;
68498   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68499   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68500
68501   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68502   {
68503     try {
68504       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68505     } catch (std::out_of_range& e) {
68506       {
68507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68508       };
68509     } catch (std::exception& e) {
68510       {
68511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68512       };
68513     } catch (Dali::DaliException e) {
68514       {
68515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68516       };
68517     } catch (...) {
68518       {
68519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68520       };
68521     }
68522   }
68523
68524   jresult = (void *)result;
68525   return jresult;
68526 }
68527
68528
68529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68530   void * jresult ;
68531   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68532   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68533
68534   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68535   {
68536     try {
68537       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68538     } catch (std::out_of_range& e) {
68539       {
68540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68541       };
68542     } catch (std::exception& e) {
68543       {
68544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68545       };
68546     } catch (Dali::DaliException e) {
68547       {
68548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68549       };
68550     } catch (...) {
68551       {
68552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68553       };
68554     }
68555   }
68556
68557   jresult = (void *)result;
68558   return jresult;
68559 }
68560
68561
68562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68563   int jresult ;
68564   int result;
68565
68566   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68567   jresult = (int)result;
68568   return jresult;
68569 }
68570
68571
68572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68573   int jresult ;
68574   int result;
68575
68576   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68577   jresult = (int)result;
68578   return jresult;
68579 }
68580
68581
68582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68583   int jresult ;
68584   int result;
68585
68586   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68587   jresult = (int)result;
68588   return jresult;
68589 }
68590
68591
68592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68593   int jresult ;
68594   int result;
68595
68596   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68597   jresult = (int)result;
68598   return jresult;
68599 }
68600
68601
68602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68603   int jresult ;
68604   int result;
68605
68606   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68607   jresult = (int)result;
68608   return jresult;
68609 }
68610
68611
68612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68613   int jresult ;
68614   int result;
68615
68616   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68617   jresult = (int)result;
68618   return jresult;
68619 }
68620
68621
68622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68623   int jresult ;
68624   int result;
68625
68626   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68627   jresult = (int)result;
68628   return jresult;
68629 }
68630
68631
68632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68633   int jresult ;
68634   int result;
68635
68636   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68637   jresult = (int)result;
68638   return jresult;
68639 }
68640
68641
68642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68643   int jresult ;
68644   int result;
68645
68646   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68647   jresult = (int)result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68653   int jresult ;
68654   int result;
68655
68656   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68657   jresult = (int)result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68663   int jresult ;
68664   int result;
68665
68666   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68667   jresult = (int)result;
68668   return jresult;
68669 }
68670
68671
68672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68673   int jresult ;
68674   int result;
68675
68676   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68677   jresult = (int)result;
68678   return jresult;
68679 }
68680
68681
68682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68683   int jresult ;
68684   int result;
68685
68686   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68687   jresult = (int)result;
68688   return jresult;
68689 }
68690
68691
68692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68693   int jresult ;
68694   int result;
68695
68696   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68697   jresult = (int)result;
68698   return jresult;
68699 }
68700
68701
68702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68703   void * jresult ;
68704   Dali::Toolkit::Scrollable::Property *result = 0 ;
68705
68706   {
68707     try {
68708       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68709     } catch (std::out_of_range& e) {
68710       {
68711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68712       };
68713     } catch (std::exception& e) {
68714       {
68715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68716       };
68717     } catch (Dali::DaliException e) {
68718       {
68719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68720       };
68721     } catch (...) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68724       };
68725     }
68726   }
68727
68728   jresult = (void *)result;
68729   return jresult;
68730 }
68731
68732
68733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68734   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68735
68736   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68737   {
68738     try {
68739       delete arg1;
68740     } catch (std::out_of_range& e) {
68741       {
68742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68743       };
68744     } catch (std::exception& e) {
68745       {
68746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68747       };
68748     } catch (Dali::DaliException e) {
68749       {
68750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68751       };
68752     } catch (...) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68755       };
68756     }
68757   }
68758
68759 }
68760
68761
68762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68763   void * jresult ;
68764   Dali::Toolkit::Scrollable *result = 0 ;
68765
68766   {
68767     try {
68768       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68776       };
68777     } catch (Dali::DaliException e) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68780       };
68781     } catch (...) {
68782       {
68783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68784       };
68785     }
68786   }
68787
68788   jresult = (void *)result;
68789   return jresult;
68790 }
68791
68792
68793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68794   void * jresult ;
68795   Dali::Toolkit::Scrollable *arg1 = 0 ;
68796   Dali::Toolkit::Scrollable *result = 0 ;
68797
68798   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68799   if (!arg1) {
68800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68801     return 0;
68802   }
68803   {
68804     try {
68805       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68806     } catch (std::out_of_range& e) {
68807       {
68808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (std::exception& e) {
68811       {
68812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (Dali::DaliException e) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68821       };
68822     }
68823   }
68824
68825   jresult = (void *)result;
68826   return jresult;
68827 }
68828
68829
68830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68831   void * jresult ;
68832   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68833   Dali::Toolkit::Scrollable *arg2 = 0 ;
68834   Dali::Toolkit::Scrollable *result = 0 ;
68835
68836   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68837   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68838   if (!arg2) {
68839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68840     return 0;
68841   }
68842   {
68843     try {
68844       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68852       };
68853     } catch (Dali::DaliException e) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68856       };
68857     } catch (...) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68860       };
68861     }
68862   }
68863
68864   jresult = (void *)result;
68865   return jresult;
68866 }
68867
68868
68869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68870   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68871
68872   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68873   {
68874     try {
68875       delete arg1;
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68883       };
68884     } catch (Dali::DaliException e) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68887       };
68888     } catch (...) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68891       };
68892     }
68893   }
68894
68895 }
68896
68897
68898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68899   void * jresult ;
68900   Dali::BaseHandle arg1 ;
68901   Dali::BaseHandle *argp1 ;
68902   Dali::Toolkit::Scrollable result;
68903
68904   argp1 = (Dali::BaseHandle *)jarg1;
68905   if (!argp1) {
68906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68907     return 0;
68908   }
68909   arg1 = *argp1;
68910   {
68911     try {
68912       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68928       };
68929     }
68930   }
68931
68932   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68938   unsigned int jresult ;
68939   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68940   bool result;
68941
68942   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68943   {
68944     try {
68945       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68946     } catch (std::out_of_range& e) {
68947       {
68948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68949       };
68950     } catch (std::exception& e) {
68951       {
68952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68953       };
68954     } catch (Dali::DaliException e) {
68955       {
68956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68957       };
68958     } catch (...) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68961       };
68962     }
68963   }
68964
68965   jresult = result;
68966   return jresult;
68967 }
68968
68969
68970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68971   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68972   bool arg2 ;
68973
68974   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68975   arg2 = jarg2 ? true : false;
68976   {
68977     try {
68978       (arg1)->SetOvershootEnabled(arg2);
68979     } catch (std::out_of_range& e) {
68980       {
68981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68982       };
68983     } catch (std::exception& e) {
68984       {
68985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68986       };
68987     } catch (Dali::DaliException e) {
68988       {
68989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68990       };
68991     } catch (...) {
68992       {
68993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68994       };
68995     }
68996   }
68997
68998 }
68999
69000
69001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69002   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69003   Dali::Vector4 *arg2 = 0 ;
69004
69005   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69006   arg2 = (Dali::Vector4 *)jarg2;
69007   if (!arg2) {
69008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69009     return ;
69010   }
69011   {
69012     try {
69013       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69014     } catch (std::out_of_range& e) {
69015       {
69016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69017       };
69018     } catch (std::exception& e) {
69019       {
69020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69021       };
69022     } catch (Dali::DaliException e) {
69023       {
69024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69025       };
69026     } catch (...) {
69027       {
69028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69029       };
69030     }
69031   }
69032
69033 }
69034
69035
69036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69037   void * jresult ;
69038   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69039   Dali::Vector4 result;
69040
69041   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69042   {
69043     try {
69044       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69045     } catch (std::out_of_range& e) {
69046       {
69047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69048       };
69049     } catch (std::exception& e) {
69050       {
69051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69052       };
69053     } catch (Dali::DaliException e) {
69054       {
69055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69056       };
69057     } catch (...) {
69058       {
69059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69060       };
69061     }
69062   }
69063
69064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69065   return jresult;
69066 }
69067
69068
69069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69070   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69071   float arg2 ;
69072
69073   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69074   arg2 = (float)jarg2;
69075   {
69076     try {
69077       (arg1)->SetOvershootAnimationSpeed(arg2);
69078     } catch (std::out_of_range& e) {
69079       {
69080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69081       };
69082     } catch (std::exception& e) {
69083       {
69084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69085       };
69086     } catch (Dali::DaliException e) {
69087       {
69088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69089       };
69090     } catch (...) {
69091       {
69092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69093       };
69094     }
69095   }
69096
69097 }
69098
69099
69100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69101   float jresult ;
69102   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69103   float result;
69104
69105   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69106   {
69107     try {
69108       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69109     } catch (std::out_of_range& e) {
69110       {
69111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69112       };
69113     } catch (std::exception& e) {
69114       {
69115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69116       };
69117     } catch (Dali::DaliException e) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69120       };
69121     } catch (...) {
69122       {
69123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69124       };
69125     }
69126   }
69127
69128   jresult = result;
69129   return jresult;
69130 }
69131
69132
69133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69134   void * jresult ;
69135   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69136   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69137
69138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69139   {
69140     try {
69141       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69142     } catch (std::out_of_range& e) {
69143       {
69144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69145       };
69146     } catch (std::exception& e) {
69147       {
69148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69149       };
69150     } catch (Dali::DaliException e) {
69151       {
69152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69153       };
69154     } catch (...) {
69155       {
69156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69157       };
69158     }
69159   }
69160
69161   jresult = (void *)result;
69162   return jresult;
69163 }
69164
69165
69166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69167   void * jresult ;
69168   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69169   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69170
69171   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69172   {
69173     try {
69174       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69175     } catch (std::out_of_range& e) {
69176       {
69177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (std::exception& e) {
69180       {
69181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69182       };
69183     } catch (Dali::DaliException e) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69186       };
69187     } catch (...) {
69188       {
69189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69190       };
69191     }
69192   }
69193
69194   jresult = (void *)result;
69195   return jresult;
69196 }
69197
69198
69199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69200   void * jresult ;
69201   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69202   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69203
69204   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69205   {
69206     try {
69207       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69208     } catch (std::out_of_range& e) {
69209       {
69210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69211       };
69212     } catch (std::exception& e) {
69213       {
69214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69215       };
69216     } catch (Dali::DaliException e) {
69217       {
69218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69219       };
69220     } catch (...) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69223       };
69224     }
69225   }
69226
69227   jresult = (void *)result;
69228   return jresult;
69229 }
69230
69231
69232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69233   unsigned int jresult ;
69234   Dali::Toolkit::ControlOrientation::Type arg1 ;
69235   bool result;
69236
69237   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69238   {
69239     try {
69240       result = (bool)Dali::Toolkit::IsVertical(arg1);
69241     } catch (std::out_of_range& e) {
69242       {
69243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69244       };
69245     } catch (std::exception& e) {
69246       {
69247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (Dali::DaliException e) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69256       };
69257     }
69258   }
69259
69260   jresult = result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69266   unsigned int jresult ;
69267   Dali::Toolkit::ControlOrientation::Type arg1 ;
69268   bool result;
69269
69270   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69271   {
69272     try {
69273       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69274     } catch (std::out_of_range& e) {
69275       {
69276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (std::exception& e) {
69279       {
69280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69281       };
69282     } catch (Dali::DaliException e) {
69283       {
69284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69285       };
69286     } catch (...) {
69287       {
69288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69289       };
69290     }
69291   }
69292
69293   jresult = result;
69294   return jresult;
69295 }
69296
69297
69298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69299   void * jresult ;
69300   unsigned int arg1 ;
69301   unsigned int arg2 ;
69302   Dali::Toolkit::ItemRange *result = 0 ;
69303
69304   arg1 = (unsigned int)jarg1;
69305   arg2 = (unsigned int)jarg2;
69306   {
69307     try {
69308       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69309     } catch (std::out_of_range& e) {
69310       {
69311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69312       };
69313     } catch (std::exception& e) {
69314       {
69315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (Dali::DaliException e) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69320       };
69321     } catch (...) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69324       };
69325     }
69326   }
69327
69328   jresult = (void *)result;
69329   return jresult;
69330 }
69331
69332
69333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69334   void * jresult ;
69335   Dali::Toolkit::ItemRange *arg1 = 0 ;
69336   Dali::Toolkit::ItemRange *result = 0 ;
69337
69338   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69339   if (!arg1) {
69340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69341     return 0;
69342   }
69343   {
69344     try {
69345       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69346     } catch (std::out_of_range& e) {
69347       {
69348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69349       };
69350     } catch (std::exception& e) {
69351       {
69352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69353       };
69354     } catch (Dali::DaliException e) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69357       };
69358     } catch (...) {
69359       {
69360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69361       };
69362     }
69363   }
69364
69365   jresult = (void *)result;
69366   return jresult;
69367 }
69368
69369
69370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69371   void * jresult ;
69372   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69373   Dali::Toolkit::ItemRange *arg2 = 0 ;
69374   Dali::Toolkit::ItemRange *result = 0 ;
69375
69376   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69377   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69378   if (!arg2) {
69379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69380     return 0;
69381   }
69382   {
69383     try {
69384       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69385     } catch (std::out_of_range& e) {
69386       {
69387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69388       };
69389     } catch (std::exception& e) {
69390       {
69391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69392       };
69393     } catch (Dali::DaliException e) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69396       };
69397     } catch (...) {
69398       {
69399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69400       };
69401     }
69402   }
69403
69404   jresult = (void *)result;
69405   return jresult;
69406 }
69407
69408
69409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69410   unsigned int jresult ;
69411   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69412   unsigned int arg2 ;
69413   bool result;
69414
69415   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69416   arg2 = (unsigned int)jarg2;
69417   {
69418     try {
69419       result = (bool)(arg1)->Within(arg2);
69420     } catch (std::out_of_range& e) {
69421       {
69422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69423       };
69424     } catch (std::exception& e) {
69425       {
69426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69427       };
69428     } catch (Dali::DaliException e) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69435       };
69436     }
69437   }
69438
69439   jresult = result;
69440   return jresult;
69441 }
69442
69443
69444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69445   void * jresult ;
69446   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69447   Dali::Toolkit::ItemRange *arg2 = 0 ;
69448   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69449
69450   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69451   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69452   if (!arg2) {
69453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69454     return 0;
69455   }
69456   {
69457     try {
69458       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69459     } catch (std::out_of_range& e) {
69460       {
69461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69462       };
69463     } catch (std::exception& e) {
69464       {
69465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69466       };
69467     } catch (Dali::DaliException e) {
69468       {
69469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69470       };
69471     } catch (...) {
69472       {
69473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69474       };
69475     }
69476   }
69477
69478   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69479   return jresult;
69480 }
69481
69482
69483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69484   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69485   unsigned int arg2 ;
69486
69487   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69488   arg2 = (unsigned int)jarg2;
69489   if (arg1) (arg1)->begin = arg2;
69490 }
69491
69492
69493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69494   unsigned int jresult ;
69495   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69496   unsigned int result;
69497
69498   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69499   result = (unsigned int) ((arg1)->begin);
69500   jresult = result;
69501   return jresult;
69502 }
69503
69504
69505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69506   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69507   unsigned int arg2 ;
69508
69509   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69510   arg2 = (unsigned int)jarg2;
69511   if (arg1) (arg1)->end = arg2;
69512 }
69513
69514
69515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69516   unsigned int jresult ;
69517   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69518   unsigned int result;
69519
69520   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69521   result = (unsigned int) ((arg1)->end);
69522   jresult = result;
69523   return jresult;
69524 }
69525
69526
69527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69528   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69529
69530   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69531   {
69532     try {
69533       delete arg1;
69534     } catch (std::out_of_range& e) {
69535       {
69536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69537       };
69538     } catch (std::exception& e) {
69539       {
69540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69541       };
69542     } catch (Dali::DaliException e) {
69543       {
69544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69545       };
69546     } catch (...) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69549       };
69550     }
69551   }
69552
69553 }
69554
69555
69556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69557   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69558
69559   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69560   {
69561     try {
69562       delete arg1;
69563     } catch (std::out_of_range& e) {
69564       {
69565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69566       };
69567     } catch (std::exception& e) {
69568       {
69569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69570       };
69571     } catch (Dali::DaliException e) {
69572       {
69573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69574       };
69575     } catch (...) {
69576       {
69577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69578       };
69579     }
69580   }
69581
69582 }
69583
69584
69585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69586   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69587   Dali::Toolkit::ControlOrientation::Type arg2 ;
69588
69589   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69590   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69591   {
69592     try {
69593       (arg1)->SetOrientation(arg2);
69594     } catch (std::out_of_range& e) {
69595       {
69596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69597       };
69598     } catch (std::exception& e) {
69599       {
69600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69601       };
69602     } catch (Dali::DaliException e) {
69603       {
69604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69605       };
69606     } catch (...) {
69607       {
69608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69609       };
69610     }
69611   }
69612
69613 }
69614
69615
69616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69617   int jresult ;
69618   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69619   Dali::Toolkit::ControlOrientation::Type result;
69620
69621   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69622   {
69623     try {
69624       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69625     } catch (std::out_of_range& e) {
69626       {
69627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69628       };
69629     } catch (std::exception& e) {
69630       {
69631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69632       };
69633     } catch (Dali::DaliException e) {
69634       {
69635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69636       };
69637     } catch (...) {
69638       {
69639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69640       };
69641     }
69642   }
69643
69644   jresult = (int)result;
69645   return jresult;
69646 }
69647
69648
69649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69650   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69651   Dali::Property::Map *arg2 = 0 ;
69652
69653   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69654   arg2 = (Dali::Property::Map *)jarg2;
69655   if (!arg2) {
69656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69657     return ;
69658   }
69659   {
69660     try {
69661       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69662     } catch (std::out_of_range& e) {
69663       {
69664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69665       };
69666     } catch (std::exception& e) {
69667       {
69668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69669       };
69670     } catch (Dali::DaliException e) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69673       };
69674     } catch (...) {
69675       {
69676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69677       };
69678     }
69679   }
69680
69681 }
69682
69683
69684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69685   void * jresult ;
69686   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69687   Dali::Property::Map result;
69688
69689   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69690   {
69691     try {
69692       result = (arg1)->GetLayoutProperties();
69693     } catch (std::out_of_range& e) {
69694       {
69695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (std::exception& e) {
69698       {
69699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69700       };
69701     } catch (Dali::DaliException e) {
69702       {
69703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69704       };
69705     } catch (...) {
69706       {
69707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69708       };
69709     }
69710   }
69711
69712   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69713   return jresult;
69714 }
69715
69716
69717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69718   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69719   unsigned int arg2 ;
69720   Dali::Vector3 *arg3 = 0 ;
69721   Dali::Vector3 *arg4 = 0 ;
69722
69723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69724   arg2 = (unsigned int)jarg2;
69725   arg3 = (Dali::Vector3 *)jarg3;
69726   if (!arg3) {
69727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69728     return ;
69729   }
69730   arg4 = (Dali::Vector3 *)jarg4;
69731   if (!arg4) {
69732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69733     return ;
69734   }
69735   {
69736     try {
69737       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69753       };
69754     }
69755   }
69756
69757 }
69758
69759
69760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69761   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69762   Dali::Vector3 *arg2 = 0 ;
69763
69764   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69765   arg2 = (Dali::Vector3 *)jarg2;
69766   if (!arg2) {
69767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69768     return ;
69769   }
69770   {
69771     try {
69772       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69773     } catch (std::out_of_range& e) {
69774       {
69775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69776       };
69777     } catch (std::exception& e) {
69778       {
69779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69780       };
69781     } catch (Dali::DaliException e) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69788       };
69789     }
69790   }
69791
69792 }
69793
69794
69795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69796   float jresult ;
69797   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69798   unsigned int arg2 ;
69799   Dali::Vector3 arg3 ;
69800   Dali::Vector3 *argp3 ;
69801   float result;
69802
69803   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69804   arg2 = (unsigned int)jarg2;
69805   argp3 = (Dali::Vector3 *)jarg3;
69806   if (!argp3) {
69807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69808     return 0;
69809   }
69810   arg3 = *argp3;
69811   {
69812     try {
69813       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69814     } catch (std::out_of_range& e) {
69815       {
69816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69817       };
69818     } catch (std::exception& e) {
69819       {
69820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69821       };
69822     } catch (Dali::DaliException e) {
69823       {
69824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69825       };
69826     } catch (...) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69829       };
69830     }
69831   }
69832
69833   jresult = result;
69834   return jresult;
69835 }
69836
69837
69838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69839   float jresult ;
69840   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69841   float arg2 ;
69842   float result;
69843
69844   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69845   arg2 = (float)jarg2;
69846   {
69847     try {
69848       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69849     } catch (std::out_of_range& e) {
69850       {
69851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (std::exception& e) {
69854       {
69855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69856       };
69857     } catch (Dali::DaliException e) {
69858       {
69859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69860       };
69861     } catch (...) {
69862       {
69863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69864       };
69865     }
69866   }
69867
69868   jresult = result;
69869   return jresult;
69870 }
69871
69872
69873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69874   float jresult ;
69875   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69876   unsigned int arg2 ;
69877   float result;
69878
69879   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69880   arg2 = (unsigned int)jarg2;
69881   {
69882     try {
69883       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69884     } catch (std::out_of_range& e) {
69885       {
69886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69887       };
69888     } catch (std::exception& e) {
69889       {
69890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69891       };
69892     } catch (Dali::DaliException e) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69895       };
69896     } catch (...) {
69897       {
69898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69899       };
69900     }
69901   }
69902
69903   jresult = result;
69904   return jresult;
69905 }
69906
69907
69908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69909   void * jresult ;
69910   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69911   float arg2 ;
69912   Dali::Vector3 arg3 ;
69913   Dali::Vector3 *argp3 ;
69914   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69915
69916   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69917   arg2 = (float)jarg2;
69918   argp3 = (Dali::Vector3 *)jarg3;
69919   if (!argp3) {
69920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69921     return 0;
69922   }
69923   arg3 = *argp3;
69924   {
69925     try {
69926       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69927     } catch (std::out_of_range& e) {
69928       {
69929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69930       };
69931     } catch (std::exception& e) {
69932       {
69933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (Dali::DaliException e) {
69936       {
69937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69938       };
69939     } catch (...) {
69940       {
69941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69942       };
69943     }
69944   }
69945
69946   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69947   return jresult;
69948 }
69949
69950
69951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69952   float jresult ;
69953   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69954   int arg2 ;
69955   float arg3 ;
69956   Dali::Vector3 *arg4 = 0 ;
69957   float result;
69958
69959   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69960   arg2 = (int)jarg2;
69961   arg3 = (float)jarg3;
69962   arg4 = (Dali::Vector3 *)jarg4;
69963   if (!arg4) {
69964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69965     return 0;
69966   }
69967   {
69968     try {
69969       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69970     } catch (std::out_of_range& e) {
69971       {
69972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69973       };
69974     } catch (std::exception& e) {
69975       {
69976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69977       };
69978     } catch (Dali::DaliException e) {
69979       {
69980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69981       };
69982     } catch (...) {
69983       {
69984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69985       };
69986     }
69987   }
69988
69989   jresult = result;
69990   return jresult;
69991 }
69992
69993
69994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69995   unsigned int jresult ;
69996   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69997   Dali::Vector3 arg2 ;
69998   Dali::Vector3 *argp2 ;
69999   unsigned int result;
70000
70001   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70002   argp2 = (Dali::Vector3 *)jarg2;
70003   if (!argp2) {
70004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70005     return 0;
70006   }
70007   arg2 = *argp2;
70008   {
70009     try {
70010       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70011     } catch (std::out_of_range& e) {
70012       {
70013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (std::exception& e) {
70016       {
70017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (Dali::DaliException e) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70022       };
70023     } catch (...) {
70024       {
70025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70026       };
70027     }
70028   }
70029
70030   jresult = result;
70031   return jresult;
70032 }
70033
70034
70035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70037   unsigned int arg2 ;
70038   Dali::Vector3 *arg3 = 0 ;
70039   Dali::Vector3 *arg4 = 0 ;
70040
70041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70042   arg2 = (unsigned int)jarg2;
70043   arg3 = (Dali::Vector3 *)jarg3;
70044   if (!arg3) {
70045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70046     return ;
70047   }
70048   arg4 = (Dali::Vector3 *)jarg4;
70049   if (!arg4) {
70050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70051     return ;
70052   }
70053   {
70054     try {
70055       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70056     } catch (std::out_of_range& e) {
70057       {
70058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70059       };
70060     } catch (std::exception& e) {
70061       {
70062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70063       };
70064     } catch (Dali::DaliException e) {
70065       {
70066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70067       };
70068     } catch (...) {
70069       {
70070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70071       };
70072     }
70073   }
70074
70075 }
70076
70077
70078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70079   void * jresult ;
70080   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70081   Dali::Degree result;
70082
70083   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70084   {
70085     try {
70086       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70087     } catch (std::out_of_range& e) {
70088       {
70089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70090       };
70091     } catch (std::exception& e) {
70092       {
70093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70094       };
70095     } catch (Dali::DaliException e) {
70096       {
70097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70098       };
70099     } catch (...) {
70100       {
70101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70102       };
70103     }
70104   }
70105
70106   jresult = new Dali::Degree((const Dali::Degree &)result);
70107   return jresult;
70108 }
70109
70110
70111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70112   float jresult ;
70113   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70114   float result;
70115
70116   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70117   {
70118     try {
70119       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70120     } catch (std::out_of_range& e) {
70121       {
70122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70123       };
70124     } catch (std::exception& e) {
70125       {
70126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70127       };
70128     } catch (Dali::DaliException e) {
70129       {
70130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70131       };
70132     } catch (...) {
70133       {
70134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70135       };
70136     }
70137   }
70138
70139   jresult = result;
70140   return jresult;
70141 }
70142
70143
70144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70145   float jresult ;
70146   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70147   float result;
70148
70149   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70150   {
70151     try {
70152       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70153     } catch (std::out_of_range& e) {
70154       {
70155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70156       };
70157     } catch (std::exception& e) {
70158       {
70159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (Dali::DaliException e) {
70162       {
70163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70164       };
70165     } catch (...) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70168       };
70169     }
70170   }
70171
70172   jresult = result;
70173   return jresult;
70174 }
70175
70176
70177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70178   float jresult ;
70179   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70180   float result;
70181
70182   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70183   {
70184     try {
70185       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70186     } catch (std::out_of_range& e) {
70187       {
70188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70189       };
70190     } catch (std::exception& e) {
70191       {
70192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70193       };
70194     } catch (Dali::DaliException e) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70197       };
70198     } catch (...) {
70199       {
70200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70201       };
70202     }
70203   }
70204
70205   jresult = result;
70206   return jresult;
70207 }
70208
70209
70210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70211   int jresult ;
70212   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70213   int arg2 ;
70214   int arg3 ;
70215   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70216   bool arg5 ;
70217   int result;
70218
70219   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70220   arg2 = (int)jarg2;
70221   arg3 = (int)jarg3;
70222   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70223   arg5 = jarg5 ? true : false;
70224   {
70225     try {
70226       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70227     } catch (std::out_of_range& e) {
70228       {
70229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70230       };
70231     } catch (std::exception& e) {
70232       {
70233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70234       };
70235     } catch (Dali::DaliException e) {
70236       {
70237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70238       };
70239     } catch (...) {
70240       {
70241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70242       };
70243     }
70244   }
70245
70246   jresult = result;
70247   return jresult;
70248 }
70249
70250
70251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70252   float jresult ;
70253   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70254   float result;
70255
70256   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70257   {
70258     try {
70259       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70260     } catch (std::out_of_range& e) {
70261       {
70262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70263       };
70264     } catch (std::exception& e) {
70265       {
70266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70267       };
70268     } catch (Dali::DaliException e) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70271       };
70272     } catch (...) {
70273       {
70274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70275       };
70276     }
70277   }
70278
70279   jresult = result;
70280   return jresult;
70281 }
70282
70283
70284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70285   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70286   Dali::Actor *arg2 = 0 ;
70287   int arg3 ;
70288   Dali::Vector3 *arg4 = 0 ;
70289   Dali::Actor *arg5 = 0 ;
70290
70291   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70292   arg2 = (Dali::Actor *)jarg2;
70293   if (!arg2) {
70294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70295     return ;
70296   }
70297   arg3 = (int)jarg3;
70298   arg4 = (Dali::Vector3 *)jarg4;
70299   if (!arg4) {
70300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70301     return ;
70302   }
70303   arg5 = (Dali::Actor *)jarg5;
70304   if (!arg5) {
70305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70306     return ;
70307   }
70308   {
70309     try {
70310       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70311     } catch (std::out_of_range& e) {
70312       {
70313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70314       };
70315     } catch (std::exception& e) {
70316       {
70317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70318       };
70319     } catch (Dali::DaliException e) {
70320       {
70321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70322       };
70323     } catch (...) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70326       };
70327     }
70328   }
70329
70330 }
70331
70332
70333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70334   void * jresult ;
70335   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70336   int arg2 ;
70337   float arg3 ;
70338   Dali::Vector3 *arg4 = 0 ;
70339   Dali::Vector3 result;
70340
70341   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70342   arg2 = (int)jarg2;
70343   arg3 = (float)jarg3;
70344   arg4 = (Dali::Vector3 *)jarg4;
70345   if (!arg4) {
70346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70347     return 0;
70348   }
70349   {
70350     try {
70351       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70352     } catch (std::out_of_range& e) {
70353       {
70354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70355       };
70356     } catch (std::exception& e) {
70357       {
70358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70359       };
70360     } catch (Dali::DaliException e) {
70361       {
70362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70363       };
70364     } catch (...) {
70365       {
70366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70367       };
70368     }
70369   }
70370
70371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70372   return jresult;
70373 }
70374
70375
70376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70377   void * jresult ;
70378   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70379   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70380
70381   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70382   {
70383     try {
70384       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70385     } catch (std::out_of_range& e) {
70386       {
70387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70388       };
70389     } catch (std::exception& e) {
70390       {
70391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70392       };
70393     } catch (Dali::DaliException e) {
70394       {
70395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70396       };
70397     } catch (...) {
70398       {
70399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70400       };
70401     }
70402   }
70403
70404   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70405   return jresult;
70406 }
70407
70408
70409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70410   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70411
70412   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70413   {
70414     try {
70415       delete arg1;
70416     } catch (std::out_of_range& e) {
70417       {
70418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70419       };
70420     } catch (std::exception& e) {
70421       {
70422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70423       };
70424     } catch (Dali::DaliException e) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70427       };
70428     } catch (...) {
70429       {
70430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70431       };
70432     }
70433   }
70434
70435 }
70436
70437
70438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70439   unsigned int jresult ;
70440   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70441   unsigned int result;
70442
70443   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70444   {
70445     try {
70446       result = (unsigned int)(arg1)->GetNumberOfItems();
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 = result;
70467   return jresult;
70468 }
70469
70470
70471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70472   void * jresult ;
70473   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70474   unsigned int arg2 ;
70475   Dali::Actor result;
70476
70477   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70478   arg2 = (unsigned int)jarg2;
70479   {
70480     try {
70481       result = (arg1)->NewItem(arg2);
70482     } catch (std::out_of_range& e) {
70483       {
70484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70485       };
70486     } catch (std::exception& e) {
70487       {
70488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70489       };
70490     } catch (Dali::DaliException e) {
70491       {
70492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70493       };
70494     } catch (...) {
70495       {
70496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70497       };
70498     }
70499   }
70500
70501   jresult = new Dali::Actor((const Dali::Actor &)result);
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70507   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70508   unsigned int arg2 ;
70509   Dali::Actor arg3 ;
70510   Dali::Actor *argp3 ;
70511
70512   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70513   arg2 = (unsigned int)jarg2;
70514   argp3 = (Dali::Actor *)jarg3;
70515   if (!argp3) {
70516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70517     return ;
70518   }
70519   arg3 = *argp3;
70520   {
70521     try {
70522       (arg1)->ItemReleased(arg2,arg3);
70523     } catch (std::out_of_range& e) {
70524       {
70525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70526       };
70527     } catch (std::exception& e) {
70528       {
70529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70530       };
70531     } catch (Dali::DaliException e) {
70532       {
70533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70534       };
70535     } catch (...) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70538       };
70539     }
70540   }
70541
70542 }
70543
70544
70545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70546   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70547   unsigned int arg2 ;
70548   Dali::Actor arg3 ;
70549   Dali::Actor *argp3 ;
70550
70551   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70552   arg2 = (unsigned int)jarg2;
70553   argp3 = (Dali::Actor *)jarg3;
70554   if (!argp3) {
70555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70556     return ;
70557   }
70558   arg3 = *argp3;
70559   {
70560     try {
70561       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70562     } catch (std::out_of_range& e) {
70563       {
70564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70565       };
70566     } catch (std::exception& e) {
70567       {
70568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70569       };
70570     } catch (Dali::DaliException e) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70573       };
70574     } catch (...) {
70575       {
70576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70577       };
70578     }
70579   }
70580
70581 }
70582
70583
70584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70585   void * jresult ;
70586   Dali::Toolkit::ItemFactory *result = 0 ;
70587
70588   {
70589     try {
70590       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70591     } catch (std::out_of_range& e) {
70592       {
70593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (std::exception& e) {
70596       {
70597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70598       };
70599     } catch (Dali::DaliException e) {
70600       {
70601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70602       };
70603     } catch (...) {
70604       {
70605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70606       };
70607     }
70608   }
70609
70610   jresult = (void *)result;
70611   return jresult;
70612 }
70613
70614
70615 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) {
70616   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70617   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70618   if (director) {
70619     director->swig_connect_director(callback0, callback1, callback2);
70620   }
70621 }
70622
70623
70624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70625   int jresult ;
70626   int result;
70627
70628   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70629   jresult = (int)result;
70630   return jresult;
70631 }
70632
70633
70634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70635   int jresult ;
70636   int result;
70637
70638   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70639   jresult = (int)result;
70640   return jresult;
70641 }
70642
70643
70644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70645   int jresult ;
70646   int result;
70647
70648   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70649   jresult = (int)result;
70650   return jresult;
70651 }
70652
70653
70654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70655   int jresult ;
70656   int result;
70657
70658   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70659   jresult = (int)result;
70660   return jresult;
70661 }
70662
70663
70664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70665   int jresult ;
70666   int result;
70667
70668   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70669   jresult = (int)result;
70670   return jresult;
70671 }
70672
70673
70674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70675   int jresult ;
70676   int result;
70677
70678   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70679   jresult = (int)result;
70680   return jresult;
70681 }
70682
70683
70684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70685   int jresult ;
70686   int result;
70687
70688   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70689   jresult = (int)result;
70690   return jresult;
70691 }
70692
70693
70694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70695   int jresult ;
70696   int result;
70697
70698   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70699   jresult = (int)result;
70700   return jresult;
70701 }
70702
70703
70704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70705   int jresult ;
70706   int result;
70707
70708   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70709   jresult = (int)result;
70710   return jresult;
70711 }
70712
70713
70714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70715   int jresult ;
70716   int result;
70717
70718   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70719   jresult = (int)result;
70720   return jresult;
70721 }
70722
70723
70724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70725   int jresult ;
70726   int result;
70727
70728   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70729   jresult = (int)result;
70730   return jresult;
70731 }
70732
70733
70734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70735   void * jresult ;
70736   Dali::Toolkit::ItemView::Property *result = 0 ;
70737
70738   {
70739     try {
70740       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70741     } catch (std::out_of_range& e) {
70742       {
70743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70744       };
70745     } catch (std::exception& e) {
70746       {
70747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70748       };
70749     } catch (Dali::DaliException e) {
70750       {
70751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70752       };
70753     } catch (...) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70756       };
70757     }
70758   }
70759
70760   jresult = (void *)result;
70761   return jresult;
70762 }
70763
70764
70765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70766   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70767
70768   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70769   {
70770     try {
70771       delete arg1;
70772     } catch (std::out_of_range& e) {
70773       {
70774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70775       };
70776     } catch (std::exception& e) {
70777       {
70778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70779       };
70780     } catch (Dali::DaliException e) {
70781       {
70782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70783       };
70784     } catch (...) {
70785       {
70786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70787       };
70788     }
70789   }
70790
70791 }
70792
70793
70794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70795   void * jresult ;
70796   Dali::Toolkit::ItemView *result = 0 ;
70797
70798   {
70799     try {
70800       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70801     } catch (std::out_of_range& e) {
70802       {
70803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70804       };
70805     } catch (std::exception& e) {
70806       {
70807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70808       };
70809     } catch (Dali::DaliException e) {
70810       {
70811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70812       };
70813     } catch (...) {
70814       {
70815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70816       };
70817     }
70818   }
70819
70820   jresult = (void *)result;
70821   return jresult;
70822 }
70823
70824
70825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70826   void * jresult ;
70827   Dali::Toolkit::ItemView *arg1 = 0 ;
70828   Dali::Toolkit::ItemView *result = 0 ;
70829
70830   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70831   if (!arg1) {
70832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70833     return 0;
70834   }
70835   {
70836     try {
70837       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70838     } catch (std::out_of_range& e) {
70839       {
70840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70841       };
70842     } catch (std::exception& e) {
70843       {
70844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70845       };
70846     } catch (Dali::DaliException e) {
70847       {
70848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70849       };
70850     } catch (...) {
70851       {
70852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70853       };
70854     }
70855   }
70856
70857   jresult = (void *)result;
70858   return jresult;
70859 }
70860
70861
70862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70863   void * jresult ;
70864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70865   Dali::Toolkit::ItemView *arg2 = 0 ;
70866   Dali::Toolkit::ItemView *result = 0 ;
70867
70868   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70869   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70870   if (!arg2) {
70871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70872     return 0;
70873   }
70874   {
70875     try {
70876       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70877     } catch (std::out_of_range& e) {
70878       {
70879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70880       };
70881     } catch (std::exception& e) {
70882       {
70883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70884       };
70885     } catch (Dali::DaliException e) {
70886       {
70887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70888       };
70889     } catch (...) {
70890       {
70891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70892       };
70893     }
70894   }
70895
70896   jresult = (void *)result;
70897   return jresult;
70898 }
70899
70900
70901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70903
70904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70905   {
70906     try {
70907       delete arg1;
70908     } catch (std::out_of_range& e) {
70909       {
70910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70911       };
70912     } catch (std::exception& e) {
70913       {
70914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70915       };
70916     } catch (Dali::DaliException e) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70919       };
70920     } catch (...) {
70921       {
70922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70923       };
70924     }
70925   }
70926
70927 }
70928
70929
70930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70931   void * jresult ;
70932   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70933   Dali::Toolkit::ItemView result;
70934
70935   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70936   if (!arg1) {
70937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70938     return 0;
70939   }
70940   {
70941     try {
70942       result = Dali::Toolkit::ItemView::New(*arg1);
70943     } catch (std::out_of_range& e) {
70944       {
70945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70946       };
70947     } catch (std::exception& e) {
70948       {
70949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70950       };
70951     } catch (Dali::DaliException e) {
70952       {
70953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70954       };
70955     } catch (...) {
70956       {
70957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70958       };
70959     }
70960   }
70961
70962   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70963   return jresult;
70964 }
70965
70966
70967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70968   void * jresult ;
70969   Dali::BaseHandle arg1 ;
70970   Dali::BaseHandle *argp1 ;
70971   Dali::Toolkit::ItemView result;
70972
70973   argp1 = (Dali::BaseHandle *)jarg1;
70974   if (!argp1) {
70975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70976     return 0;
70977   }
70978   arg1 = *argp1;
70979   {
70980     try {
70981       result = Dali::Toolkit::ItemView::DownCast(arg1);
70982     } catch (std::out_of_range& e) {
70983       {
70984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70985       };
70986     } catch (std::exception& e) {
70987       {
70988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70989       };
70990     } catch (Dali::DaliException e) {
70991       {
70992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70993       };
70994     } catch (...) {
70995       {
70996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70997       };
70998     }
70999   }
71000
71001   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71002   return jresult;
71003 }
71004
71005
71006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71007   unsigned int jresult ;
71008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71009   unsigned int result;
71010
71011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71012   {
71013     try {
71014       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71015     } catch (std::out_of_range& e) {
71016       {
71017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71018       };
71019     } catch (std::exception& e) {
71020       {
71021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71022       };
71023     } catch (Dali::DaliException e) {
71024       {
71025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71026       };
71027     } catch (...) {
71028       {
71029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71030       };
71031     }
71032   }
71033
71034   jresult = result;
71035   return jresult;
71036 }
71037
71038
71039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71041   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71042
71043   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71044   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71045   if (!arg2) {
71046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71047     return ;
71048   }
71049   {
71050     try {
71051       (arg1)->AddLayout(*arg2);
71052     } catch (std::out_of_range& e) {
71053       {
71054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71055       };
71056     } catch (std::exception& e) {
71057       {
71058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71059       };
71060     } catch (Dali::DaliException e) {
71061       {
71062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71063       };
71064     } catch (...) {
71065       {
71066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71067       };
71068     }
71069   }
71070
71071 }
71072
71073
71074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71075   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71076   unsigned int arg2 ;
71077
71078   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71079   arg2 = (unsigned int)jarg2;
71080   {
71081     try {
71082       (arg1)->RemoveLayout(arg2);
71083     } catch (std::out_of_range& e) {
71084       {
71085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71086       };
71087     } catch (std::exception& e) {
71088       {
71089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71090       };
71091     } catch (Dali::DaliException e) {
71092       {
71093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71094       };
71095     } catch (...) {
71096       {
71097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71098       };
71099     }
71100   }
71101
71102 }
71103
71104
71105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71106   void * jresult ;
71107   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71108   unsigned int arg2 ;
71109   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71110
71111   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71112   arg2 = (unsigned int)jarg2;
71113   {
71114     try {
71115       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71116     } catch (std::out_of_range& e) {
71117       {
71118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71119       };
71120     } catch (std::exception& e) {
71121       {
71122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71123       };
71124     } catch (Dali::DaliException e) {
71125       {
71126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71127       };
71128     } catch (...) {
71129       {
71130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71131       };
71132     }
71133   }
71134
71135   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71136   return jresult;
71137 }
71138
71139
71140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71141   void * jresult ;
71142   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71143   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71144
71145   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71146   {
71147     try {
71148       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71149     } catch (std::out_of_range& e) {
71150       {
71151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (std::exception& e) {
71154       {
71155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71156       };
71157     } catch (Dali::DaliException e) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71160       };
71161     } catch (...) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71164       };
71165     }
71166   }
71167
71168   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71169   return jresult;
71170 }
71171
71172
71173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71174   float jresult ;
71175   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71176   Dali::Toolkit::ItemId arg2 ;
71177   float result;
71178
71179   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71180   arg2 = (Dali::Toolkit::ItemId)jarg2;
71181   {
71182     try {
71183       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71184     } catch (std::out_of_range& e) {
71185       {
71186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71187       };
71188     } catch (std::exception& e) {
71189       {
71190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71191       };
71192     } catch (Dali::DaliException e) {
71193       {
71194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71195       };
71196     } catch (...) {
71197       {
71198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71199       };
71200     }
71201   }
71202
71203   jresult = result;
71204   return jresult;
71205 }
71206
71207
71208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71209   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71210   unsigned int arg2 ;
71211   Dali::Vector3 arg3 ;
71212   float arg4 ;
71213   Dali::Vector3 *argp3 ;
71214
71215   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71216   arg2 = (unsigned int)jarg2;
71217   argp3 = (Dali::Vector3 *)jarg3;
71218   if (!argp3) {
71219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71220     return ;
71221   }
71222   arg3 = *argp3;
71223   arg4 = (float)jarg4;
71224   {
71225     try {
71226       (arg1)->ActivateLayout(arg2,arg3,arg4);
71227     } catch (std::out_of_range& e) {
71228       {
71229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71230       };
71231     } catch (std::exception& e) {
71232       {
71233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71234       };
71235     } catch (Dali::DaliException e) {
71236       {
71237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71238       };
71239     } catch (...) {
71240       {
71241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71242       };
71243     }
71244   }
71245
71246 }
71247
71248
71249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71250   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71251
71252   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71253   {
71254     try {
71255       (arg1)->DeactivateCurrentLayout();
71256     } catch (std::out_of_range& e) {
71257       {
71258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71259       };
71260     } catch (std::exception& e) {
71261       {
71262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71263       };
71264     } catch (Dali::DaliException e) {
71265       {
71266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71267       };
71268     } catch (...) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71271       };
71272     }
71273   }
71274
71275 }
71276
71277
71278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71279   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71280   float arg2 ;
71281
71282   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71283   arg2 = (float)jarg2;
71284   {
71285     try {
71286       (arg1)->SetMinimumSwipeSpeed(arg2);
71287     } catch (std::out_of_range& e) {
71288       {
71289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71290       };
71291     } catch (std::exception& e) {
71292       {
71293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71294       };
71295     } catch (Dali::DaliException e) {
71296       {
71297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71298       };
71299     } catch (...) {
71300       {
71301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71302       };
71303     }
71304   }
71305
71306 }
71307
71308
71309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71310   float jresult ;
71311   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71312   float result;
71313
71314   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71315   {
71316     try {
71317       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71318     } catch (std::out_of_range& e) {
71319       {
71320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71321       };
71322     } catch (std::exception& e) {
71323       {
71324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71325       };
71326     } catch (Dali::DaliException e) {
71327       {
71328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71329       };
71330     } catch (...) {
71331       {
71332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71333       };
71334     }
71335   }
71336
71337   jresult = result;
71338   return jresult;
71339 }
71340
71341
71342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71343   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71344   float arg2 ;
71345
71346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71347   arg2 = (float)jarg2;
71348   {
71349     try {
71350       (arg1)->SetMinimumSwipeDistance(arg2);
71351     } catch (std::out_of_range& e) {
71352       {
71353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71354       };
71355     } catch (std::exception& e) {
71356       {
71357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71358       };
71359     } catch (Dali::DaliException e) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71362       };
71363     } catch (...) {
71364       {
71365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71366       };
71367     }
71368   }
71369
71370 }
71371
71372
71373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71374   float jresult ;
71375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71376   float result;
71377
71378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71379   {
71380     try {
71381       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71382     } catch (std::out_of_range& e) {
71383       {
71384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71385       };
71386     } catch (std::exception& e) {
71387       {
71388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71389       };
71390     } catch (Dali::DaliException e) {
71391       {
71392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71393       };
71394     } catch (...) {
71395       {
71396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71397       };
71398     }
71399   }
71400
71401   jresult = result;
71402   return jresult;
71403 }
71404
71405
71406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71408   float arg2 ;
71409
71410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71411   arg2 = (float)jarg2;
71412   {
71413     try {
71414       (arg1)->SetWheelScrollDistanceStep(arg2);
71415     } catch (std::out_of_range& e) {
71416       {
71417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71418       };
71419     } catch (std::exception& e) {
71420       {
71421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71422       };
71423     } catch (Dali::DaliException e) {
71424       {
71425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71426       };
71427     } catch (...) {
71428       {
71429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71430       };
71431     }
71432   }
71433
71434 }
71435
71436
71437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71438   float jresult ;
71439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71440   float result;
71441
71442   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71443   {
71444     try {
71445       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71446     } catch (std::out_of_range& e) {
71447       {
71448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71449       };
71450     } catch (std::exception& e) {
71451       {
71452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71453       };
71454     } catch (Dali::DaliException e) {
71455       {
71456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71457       };
71458     } catch (...) {
71459       {
71460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71461       };
71462     }
71463   }
71464
71465   jresult = result;
71466   return jresult;
71467 }
71468
71469
71470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71472   bool arg2 ;
71473
71474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71475   arg2 = jarg2 ? true : false;
71476   {
71477     try {
71478       (arg1)->SetAnchoring(arg2);
71479     } catch (std::out_of_range& e) {
71480       {
71481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71482       };
71483     } catch (std::exception& e) {
71484       {
71485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71486       };
71487     } catch (Dali::DaliException e) {
71488       {
71489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71490       };
71491     } catch (...) {
71492       {
71493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71494       };
71495     }
71496   }
71497
71498 }
71499
71500 //// ========================= end of part 3 =============================
71501
71502 //// ========================== start part 4 ===============================
71503
71504
71505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71506   unsigned int jresult ;
71507   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71508   bool result;
71509
71510   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71511   {
71512     try {
71513       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71521       };
71522     } catch (Dali::DaliException e) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71525       };
71526     } catch (...) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71529       };
71530     }
71531   }
71532
71533   jresult = result;
71534   return jresult;
71535 }
71536
71537
71538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71539   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71540   float arg2 ;
71541
71542   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71543   arg2 = (float)jarg2;
71544   {
71545     try {
71546       (arg1)->SetAnchoringDuration(arg2);
71547     } catch (std::out_of_range& e) {
71548       {
71549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71550       };
71551     } catch (std::exception& e) {
71552       {
71553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71554       };
71555     } catch (Dali::DaliException e) {
71556       {
71557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71558       };
71559     } catch (...) {
71560       {
71561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71562       };
71563     }
71564   }
71565
71566 }
71567
71568
71569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71570   float jresult ;
71571   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71572   float result;
71573
71574   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71575   {
71576     try {
71577       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71578     } catch (std::out_of_range& e) {
71579       {
71580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71581       };
71582     } catch (std::exception& e) {
71583       {
71584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71585       };
71586     } catch (Dali::DaliException e) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71589       };
71590     } catch (...) {
71591       {
71592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71593       };
71594     }
71595   }
71596
71597   jresult = result;
71598   return jresult;
71599 }
71600
71601
71602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71604   Dali::Toolkit::ItemId arg2 ;
71605   float arg3 ;
71606
71607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71608   arg2 = (Dali::Toolkit::ItemId)jarg2;
71609   arg3 = (float)jarg3;
71610   {
71611     try {
71612       (arg1)->ScrollToItem(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_SetRefreshInterval(void * jarg1, float jarg2) {
71636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71637   float arg2 ;
71638
71639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71640   arg2 = (float)jarg2;
71641   {
71642     try {
71643       (arg1)->SetRefreshInterval(arg2);
71644     } catch (std::out_of_range& e) {
71645       {
71646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71647       };
71648     } catch (std::exception& e) {
71649       {
71650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71651       };
71652     } catch (Dali::DaliException e) {
71653       {
71654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71655       };
71656     } catch (...) {
71657       {
71658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71659       };
71660     }
71661   }
71662
71663 }
71664
71665
71666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71667   float jresult ;
71668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71669   float result;
71670
71671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71672   {
71673     try {
71674       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71675     } catch (std::out_of_range& e) {
71676       {
71677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71678       };
71679     } catch (std::exception& e) {
71680       {
71681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71682       };
71683     } catch (Dali::DaliException e) {
71684       {
71685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71686       };
71687     } catch (...) {
71688       {
71689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71690       };
71691     }
71692   }
71693
71694   jresult = result;
71695   return jresult;
71696 }
71697
71698
71699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71701
71702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71703   {
71704     try {
71705       (arg1)->Refresh();
71706     } catch (std::out_of_range& e) {
71707       {
71708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71709       };
71710     } catch (std::exception& e) {
71711       {
71712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71713       };
71714     } catch (Dali::DaliException e) {
71715       {
71716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71717       };
71718     } catch (...) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71721       };
71722     }
71723   }
71724
71725 }
71726
71727
71728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71729   void * jresult ;
71730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71731   Dali::Toolkit::ItemId arg2 ;
71732   Dali::Actor result;
71733
71734   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71735   arg2 = (Dali::Toolkit::ItemId)jarg2;
71736   {
71737     try {
71738       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71739     } catch (std::out_of_range& e) {
71740       {
71741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71742       };
71743     } catch (std::exception& e) {
71744       {
71745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71746       };
71747     } catch (Dali::DaliException e) {
71748       {
71749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71750       };
71751     } catch (...) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71754       };
71755     }
71756   }
71757
71758   jresult = new Dali::Actor((const Dali::Actor &)result);
71759   return jresult;
71760 }
71761
71762
71763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71764   unsigned int jresult ;
71765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71766   Dali::Actor arg2 ;
71767   Dali::Actor *argp2 ;
71768   Dali::Toolkit::ItemId result;
71769
71770   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71771   argp2 = (Dali::Actor *)jarg2;
71772   if (!argp2) {
71773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71774     return 0;
71775   }
71776   arg2 = *argp2;
71777   {
71778     try {
71779       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71780     } catch (std::out_of_range& e) {
71781       {
71782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71783       };
71784     } catch (std::exception& e) {
71785       {
71786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71787       };
71788     } catch (Dali::DaliException e) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71791       };
71792     } catch (...) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71795       };
71796     }
71797   }
71798
71799   jresult = result;
71800   return jresult;
71801 }
71802
71803
71804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71805   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71806   Dali::Toolkit::Item arg2 ;
71807   float arg3 ;
71808   Dali::Toolkit::Item *argp2 ;
71809
71810   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71811   argp2 = (Dali::Toolkit::Item *)jarg2;
71812   if (!argp2) {
71813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71814     return ;
71815   }
71816   arg2 = *argp2;
71817   arg3 = (float)jarg3;
71818   {
71819     try {
71820       (arg1)->InsertItem(arg2,arg3);
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_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71845   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71846   float arg3 ;
71847
71848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71849   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71850   if (!arg2) {
71851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71852     return ;
71853   }
71854   arg3 = (float)jarg3;
71855   {
71856     try {
71857       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71858     } catch (std::out_of_range& e) {
71859       {
71860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71861       };
71862     } catch (std::exception& e) {
71863       {
71864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71865       };
71866     } catch (Dali::DaliException e) {
71867       {
71868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71869       };
71870     } catch (...) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71873       };
71874     }
71875   }
71876
71877 }
71878
71879
71880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71882   Dali::Toolkit::ItemId arg2 ;
71883   float arg3 ;
71884
71885   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71886   arg2 = (Dali::Toolkit::ItemId)jarg2;
71887   arg3 = (float)jarg3;
71888   {
71889     try {
71890       (arg1)->RemoveItem(arg2,arg3);
71891     } catch (std::out_of_range& e) {
71892       {
71893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71894       };
71895     } catch (std::exception& e) {
71896       {
71897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71898       };
71899     } catch (Dali::DaliException e) {
71900       {
71901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71902       };
71903     } catch (...) {
71904       {
71905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71906       };
71907     }
71908   }
71909
71910 }
71911
71912
71913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71915   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71916   float arg3 ;
71917
71918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71919   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71920   if (!arg2) {
71921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71922     return ;
71923   }
71924   arg3 = (float)jarg3;
71925   {
71926     try {
71927       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71928     } catch (std::out_of_range& e) {
71929       {
71930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71931       };
71932     } catch (std::exception& e) {
71933       {
71934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71935       };
71936     } catch (Dali::DaliException e) {
71937       {
71938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71939       };
71940     } catch (...) {
71941       {
71942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71943       };
71944     }
71945   }
71946
71947 }
71948
71949
71950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71952   Dali::Toolkit::Item arg2 ;
71953   float arg3 ;
71954   Dali::Toolkit::Item *argp2 ;
71955
71956   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71957   argp2 = (Dali::Toolkit::Item *)jarg2;
71958   if (!argp2) {
71959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71960     return ;
71961   }
71962   arg2 = *argp2;
71963   arg3 = (float)jarg3;
71964   {
71965     try {
71966       (arg1)->ReplaceItem(arg2,arg3);
71967     } catch (std::out_of_range& e) {
71968       {
71969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71970       };
71971     } catch (std::exception& e) {
71972       {
71973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71974       };
71975     } catch (Dali::DaliException e) {
71976       {
71977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71982       };
71983     }
71984   }
71985
71986 }
71987
71988
71989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71990   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71991   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71992   float arg3 ;
71993
71994   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71995   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71996   if (!arg2) {
71997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71998     return ;
71999   }
72000   arg3 = (float)jarg3;
72001   {
72002     try {
72003       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72004     } catch (std::out_of_range& e) {
72005       {
72006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72007       };
72008     } catch (std::exception& e) {
72009       {
72010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72011       };
72012     } catch (Dali::DaliException e) {
72013       {
72014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72015       };
72016     } catch (...) {
72017       {
72018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72019       };
72020     }
72021   }
72022
72023 }
72024
72025
72026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
72027   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72028   Dali::Vector3 *arg2 = 0 ;
72029
72030   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72031   arg2 = (Dali::Vector3 *)jarg2;
72032   if (!arg2) {
72033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72034     return ;
72035   }
72036   {
72037     try {
72038       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
72039     } catch (std::out_of_range& e) {
72040       {
72041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72042       };
72043     } catch (std::exception& e) {
72044       {
72045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72046       };
72047     } catch (Dali::DaliException e) {
72048       {
72049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72050       };
72051     } catch (...) {
72052       {
72053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72054       };
72055     }
72056   }
72057
72058 }
72059
72060
72061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
72062   void * jresult ;
72063   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72064   Dali::Vector3 result;
72065
72066   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72067   {
72068     try {
72069       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
72070     } catch (std::out_of_range& e) {
72071       {
72072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72073       };
72074     } catch (std::exception& e) {
72075       {
72076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72077       };
72078     } catch (Dali::DaliException e) {
72079       {
72080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72081       };
72082     } catch (...) {
72083       {
72084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72085       };
72086     }
72087   }
72088
72089   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72090   return jresult;
72091 }
72092
72093
72094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
72095   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72096   Dali::Vector3 *arg2 = 0 ;
72097
72098   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72099   arg2 = (Dali::Vector3 *)jarg2;
72100   if (!arg2) {
72101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72102     return ;
72103   }
72104   {
72105     try {
72106       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
72107     } catch (std::out_of_range& e) {
72108       {
72109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72110       };
72111     } catch (std::exception& e) {
72112       {
72113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72114       };
72115     } catch (Dali::DaliException e) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72118       };
72119     } catch (...) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72122       };
72123     }
72124   }
72125
72126 }
72127
72128
72129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72130   void * jresult ;
72131   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72132   Dali::Vector3 result;
72133
72134   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72135   {
72136     try {
72137       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72138     } catch (std::out_of_range& e) {
72139       {
72140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72141       };
72142     } catch (std::exception& e) {
72143       {
72144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72145       };
72146     } catch (Dali::DaliException e) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72149       };
72150     } catch (...) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72153       };
72154     }
72155   }
72156
72157   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72158   return jresult;
72159 }
72160
72161
72162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72163   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72164   Dali::Toolkit::ItemRange *arg2 = 0 ;
72165
72166   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72167   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72168   if (!arg2) {
72169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72170     return ;
72171   }
72172   {
72173     try {
72174       (arg1)->GetItemsRange(*arg2);
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (Dali::DaliException e) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72186       };
72187     } catch (...) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72190       };
72191     }
72192   }
72193
72194 }
72195
72196
72197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72198   void * jresult ;
72199   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72200   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72201
72202   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72203   {
72204     try {
72205       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72206     } catch (std::out_of_range& e) {
72207       {
72208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72209       };
72210     } catch (std::exception& e) {
72211       {
72212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72213       };
72214     } catch (Dali::DaliException e) {
72215       {
72216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72217       };
72218     } catch (...) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72221       };
72222     }
72223   }
72224
72225   jresult = (void *)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72231   Dali::Vector3 *arg1 = 0 ;
72232   PropertyInputContainer *arg2 = 0 ;
72233
72234   arg1 = (Dali::Vector3 *)jarg1;
72235   if (!arg1) {
72236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72237     return ;
72238   }
72239   arg2 = (PropertyInputContainer *)jarg2;
72240   if (!arg2) {
72241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72242     return ;
72243   }
72244   {
72245     try {
72246       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72247     } catch (std::out_of_range& e) {
72248       {
72249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72250       };
72251     } catch (std::exception& e) {
72252       {
72253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72254       };
72255     } catch (Dali::DaliException e) {
72256       {
72257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72258       };
72259     } catch (...) {
72260       {
72261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72262       };
72263     }
72264   }
72265
72266 }
72267
72268
72269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72270   Dali::Vector3 *arg1 = 0 ;
72271   PropertyInputContainer *arg2 = 0 ;
72272
72273   arg1 = (Dali::Vector3 *)jarg1;
72274   if (!arg1) {
72275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72276     return ;
72277   }
72278   arg2 = (PropertyInputContainer *)jarg2;
72279   if (!arg2) {
72280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72281     return ;
72282   }
72283   {
72284     try {
72285       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72286     } catch (std::out_of_range& e) {
72287       {
72288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72289       };
72290     } catch (std::exception& e) {
72291       {
72292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72293       };
72294     } catch (Dali::DaliException e) {
72295       {
72296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72297       };
72298     } catch (...) {
72299       {
72300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72301       };
72302     }
72303   }
72304
72305 }
72306
72307
72308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72309   void * jresult ;
72310   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72311
72312   {
72313     try {
72314       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72315     } catch (std::out_of_range& e) {
72316       {
72317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72318       };
72319     } catch (std::exception& e) {
72320       {
72321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (Dali::DaliException e) {
72324       {
72325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72326       };
72327     } catch (...) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72330       };
72331     }
72332   }
72333
72334   jresult = (void *)result;
72335   return jresult;
72336 }
72337
72338
72339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72340   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72341
72342   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72343   {
72344     try {
72345       delete arg1;
72346     } catch (std::out_of_range& e) {
72347       {
72348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72349       };
72350     } catch (std::exception& e) {
72351       {
72352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72353       };
72354     } catch (Dali::DaliException e) {
72355       {
72356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72357       };
72358     } catch (...) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72361       };
72362     }
72363   }
72364
72365 }
72366
72367
72368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72369   void * jresult ;
72370   Dali::Path arg1 ;
72371   Dali::Vector3 *arg2 = 0 ;
72372   Dali::Property::Index arg3 ;
72373   Dali::Vector3 *arg4 = 0 ;
72374   unsigned int arg5 ;
72375   Dali::Path *argp1 ;
72376   Dali::Toolkit::ScrollViewPagePathEffect result;
72377
72378   argp1 = (Dali::Path *)jarg1;
72379   if (!argp1) {
72380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72381     return 0;
72382   }
72383   arg1 = *argp1;
72384   arg2 = (Dali::Vector3 *)jarg2;
72385   if (!arg2) {
72386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72387     return 0;
72388   }
72389   arg3 = (Dali::Property::Index)jarg3;
72390   arg4 = (Dali::Vector3 *)jarg4;
72391   if (!arg4) {
72392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72393     return 0;
72394   }
72395   arg5 = (unsigned int)jarg5;
72396   {
72397     try {
72398       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72406       };
72407     } catch (Dali::DaliException e) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72414       };
72415     }
72416   }
72417
72418   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72419   return jresult;
72420 }
72421
72422
72423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72424   void * jresult ;
72425   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72426
72427   {
72428     try {
72429       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72430     } catch (std::out_of_range& e) {
72431       {
72432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72433       };
72434     } catch (std::exception& e) {
72435       {
72436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72437       };
72438     } catch (Dali::DaliException e) {
72439       {
72440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72441       };
72442     } catch (...) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72445       };
72446     }
72447   }
72448
72449   jresult = (void *)result;
72450   return jresult;
72451 }
72452
72453
72454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72455   void * jresult ;
72456   Dali::BaseHandle arg1 ;
72457   Dali::BaseHandle *argp1 ;
72458   Dali::Toolkit::ScrollViewPagePathEffect result;
72459
72460   argp1 = (Dali::BaseHandle *)jarg1;
72461   if (!argp1) {
72462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72463     return 0;
72464   }
72465   arg1 = *argp1;
72466   {
72467     try {
72468       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72469     } catch (std::out_of_range& e) {
72470       {
72471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72472       };
72473     } catch (std::exception& e) {
72474       {
72475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72476       };
72477     } catch (Dali::DaliException e) {
72478       {
72479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72480       };
72481     } catch (...) {
72482       {
72483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72484       };
72485     }
72486   }
72487
72488   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72489   return jresult;
72490 }
72491
72492
72493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72494   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72495   Dali::Actor arg2 ;
72496   unsigned int arg3 ;
72497   Dali::Actor *argp2 ;
72498
72499   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72500   argp2 = (Dali::Actor *)jarg2;
72501   if (!argp2) {
72502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72503     return ;
72504   }
72505   arg2 = *argp2;
72506   arg3 = (unsigned int)jarg3;
72507   {
72508     try {
72509       (arg1)->ApplyToPage(arg2,arg3);
72510     } catch (std::out_of_range& e) {
72511       {
72512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72513       };
72514     } catch (std::exception& e) {
72515       {
72516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72517       };
72518     } catch (Dali::DaliException e) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72525       };
72526     }
72527   }
72528
72529 }
72530
72531
72532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72533   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72534
72535   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72536   {
72537     try {
72538       delete arg1;
72539     } catch (std::out_of_range& e) {
72540       {
72541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72542       };
72543     } catch (std::exception& e) {
72544       {
72545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72546       };
72547     } catch (Dali::DaliException e) {
72548       {
72549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72550       };
72551     } catch (...) {
72552       {
72553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72554       };
72555     }
72556   }
72557
72558 }
72559
72560
72561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72562   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72563   Dali::Toolkit::ClampState arg2 ;
72564
72565   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72566   arg2 = (Dali::Toolkit::ClampState)jarg2;
72567   if (arg1) (arg1)->x = arg2;
72568 }
72569
72570
72571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72572   int jresult ;
72573   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72574   Dali::Toolkit::ClampState result;
72575
72576   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72577   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72578   jresult = (int)result;
72579   return jresult;
72580 }
72581
72582
72583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72584   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72585   Dali::Toolkit::ClampState arg2 ;
72586
72587   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72588   arg2 = (Dali::Toolkit::ClampState)jarg2;
72589   if (arg1) (arg1)->y = arg2;
72590 }
72591
72592
72593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72594   int jresult ;
72595   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72596   Dali::Toolkit::ClampState result;
72597
72598   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72599   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72600   jresult = (int)result;
72601   return jresult;
72602 }
72603
72604
72605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72606   void * jresult ;
72607   Dali::Toolkit::ClampState2D *result = 0 ;
72608
72609   {
72610     try {
72611       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72612     } catch (std::out_of_range& e) {
72613       {
72614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72615       };
72616     } catch (std::exception& e) {
72617       {
72618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72619       };
72620     } catch (Dali::DaliException e) {
72621       {
72622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72623       };
72624     } catch (...) {
72625       {
72626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72627       };
72628     }
72629   }
72630
72631   jresult = (void *)result;
72632   return jresult;
72633 }
72634
72635
72636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72637   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72638
72639   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72640   {
72641     try {
72642       delete arg1;
72643     } catch (std::out_of_range& e) {
72644       {
72645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72646       };
72647     } catch (std::exception& e) {
72648       {
72649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72650       };
72651     } catch (Dali::DaliException e) {
72652       {
72653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72654       };
72655     } catch (...) {
72656       {
72657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72658       };
72659     }
72660   }
72661
72662 }
72663
72664
72665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72666   void * jresult ;
72667   float arg1 ;
72668   float arg2 ;
72669   bool arg3 ;
72670   Dali::Toolkit::RulerDomain *result = 0 ;
72671
72672   arg1 = (float)jarg1;
72673   arg2 = (float)jarg2;
72674   arg3 = jarg3 ? true : false;
72675   {
72676     try {
72677       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72678     } catch (std::out_of_range& e) {
72679       {
72680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72681       };
72682     } catch (std::exception& e) {
72683       {
72684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72685       };
72686     } catch (Dali::DaliException e) {
72687       {
72688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72689       };
72690     } catch (...) {
72691       {
72692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72693       };
72694     }
72695   }
72696
72697   jresult = (void *)result;
72698   return jresult;
72699 }
72700
72701
72702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72703   void * jresult ;
72704   float arg1 ;
72705   float arg2 ;
72706   Dali::Toolkit::RulerDomain *result = 0 ;
72707
72708   arg1 = (float)jarg1;
72709   arg2 = (float)jarg2;
72710   {
72711     try {
72712       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72713     } catch (std::out_of_range& e) {
72714       {
72715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72716       };
72717     } catch (std::exception& e) {
72718       {
72719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72720       };
72721     } catch (Dali::DaliException e) {
72722       {
72723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72724       };
72725     } catch (...) {
72726       {
72727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72728       };
72729     }
72730   }
72731
72732   jresult = (void *)result;
72733   return jresult;
72734 }
72735
72736
72737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72738   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72739   float arg2 ;
72740
72741   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72742   arg2 = (float)jarg2;
72743   if (arg1) (arg1)->min = arg2;
72744 }
72745
72746
72747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72748   float jresult ;
72749   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72750   float result;
72751
72752   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72753   result = (float) ((arg1)->min);
72754   jresult = result;
72755   return jresult;
72756 }
72757
72758
72759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72760   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72761   float arg2 ;
72762
72763   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72764   arg2 = (float)jarg2;
72765   if (arg1) (arg1)->max = arg2;
72766 }
72767
72768
72769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72770   float jresult ;
72771   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72772   float result;
72773
72774   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72775   result = (float) ((arg1)->max);
72776   jresult = result;
72777   return jresult;
72778 }
72779
72780
72781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72782   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72783   bool arg2 ;
72784
72785   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72786   arg2 = jarg2 ? true : false;
72787   if (arg1) (arg1)->enabled = arg2;
72788 }
72789
72790
72791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72792   unsigned int jresult ;
72793   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72794   bool result;
72795
72796   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72797   result = (bool) ((arg1)->enabled);
72798   jresult = result;
72799   return jresult;
72800 }
72801
72802
72803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72804   float jresult ;
72805   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72806   float arg2 ;
72807   float arg3 ;
72808   float arg4 ;
72809   float result;
72810
72811   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72812   arg2 = (float)jarg2;
72813   arg3 = (float)jarg3;
72814   arg4 = (float)jarg4;
72815   {
72816     try {
72817       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72818     } catch (std::out_of_range& e) {
72819       {
72820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72821       };
72822     } catch (std::exception& e) {
72823       {
72824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72825       };
72826     } catch (Dali::DaliException e) {
72827       {
72828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72829       };
72830     } catch (...) {
72831       {
72832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72833       };
72834     }
72835   }
72836
72837   jresult = result;
72838   return jresult;
72839 }
72840
72841
72842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72843   float jresult ;
72844   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72845   float arg2 ;
72846   float arg3 ;
72847   float result;
72848
72849   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72850   arg2 = (float)jarg2;
72851   arg3 = (float)jarg3;
72852   {
72853     try {
72854       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72855     } catch (std::out_of_range& e) {
72856       {
72857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72858       };
72859     } catch (std::exception& e) {
72860       {
72861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72862       };
72863     } catch (Dali::DaliException e) {
72864       {
72865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72866       };
72867     } catch (...) {
72868       {
72869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72870       };
72871     }
72872   }
72873
72874   jresult = result;
72875   return jresult;
72876 }
72877
72878
72879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72880   float jresult ;
72881   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72882   float arg2 ;
72883   float result;
72884
72885   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72886   arg2 = (float)jarg2;
72887   {
72888     try {
72889       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
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 float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72915   float jresult ;
72916   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72917   float arg2 ;
72918   float arg3 ;
72919   float arg4 ;
72920   Dali::Toolkit::ClampState *arg5 = 0 ;
72921   float result;
72922
72923   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72924   arg2 = (float)jarg2;
72925   arg3 = (float)jarg3;
72926   arg4 = (float)jarg4;
72927   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72928   if (!arg5) {
72929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72930     return 0;
72931   }
72932   {
72933     try {
72934       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72935     } catch (std::out_of_range& e) {
72936       {
72937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72938       };
72939     } catch (std::exception& e) {
72940       {
72941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72942       };
72943     } catch (Dali::DaliException e) {
72944       {
72945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72946       };
72947     } catch (...) {
72948       {
72949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72950       };
72951     }
72952   }
72953
72954   jresult = result;
72955   return jresult;
72956 }
72957
72958
72959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72960   float jresult ;
72961   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72962   float result;
72963
72964   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72965   {
72966     try {
72967       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72968     } catch (std::out_of_range& e) {
72969       {
72970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72971       };
72972     } catch (std::exception& e) {
72973       {
72974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72975       };
72976     } catch (Dali::DaliException e) {
72977       {
72978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72979       };
72980     } catch (...) {
72981       {
72982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72983       };
72984     }
72985   }
72986
72987   jresult = result;
72988   return jresult;
72989 }
72990
72991
72992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72993   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72994
72995   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72996   {
72997     try {
72998       delete arg1;
72999     } catch (std::out_of_range& e) {
73000       {
73001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73002       };
73003     } catch (std::exception& e) {
73004       {
73005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73006       };
73007     } catch (Dali::DaliException e) {
73008       {
73009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73010       };
73011     } catch (...) {
73012       {
73013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73014       };
73015     }
73016   }
73017
73018 }
73019
73020
73021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
73022   float jresult ;
73023   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73024   float arg2 ;
73025   float arg3 ;
73026   float result;
73027
73028   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73029   arg2 = (float)jarg2;
73030   arg3 = (float)jarg3;
73031   {
73032     try {
73033       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
73034     } catch (std::out_of_range& e) {
73035       {
73036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73037       };
73038     } catch (std::exception& e) {
73039       {
73040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73041       };
73042     } catch (Dali::DaliException e) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73045       };
73046     } catch (...) {
73047       {
73048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73049       };
73050     }
73051   }
73052
73053   jresult = result;
73054   return jresult;
73055 }
73056
73057
73058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
73059   float jresult ;
73060   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73061   float arg2 ;
73062   float result;
73063
73064   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73065   arg2 = (float)jarg2;
73066   {
73067     try {
73068       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
73069     } catch (std::out_of_range& e) {
73070       {
73071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73072       };
73073     } catch (std::exception& e) {
73074       {
73075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73076       };
73077     } catch (Dali::DaliException e) {
73078       {
73079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73080       };
73081     } catch (...) {
73082       {
73083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73084       };
73085     }
73086   }
73087
73088   jresult = result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73094   float jresult ;
73095   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73096   unsigned int arg2 ;
73097   unsigned int *arg3 = 0 ;
73098   bool arg4 ;
73099   float result;
73100
73101   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73102   arg2 = (unsigned int)jarg2;
73103   arg3 = (unsigned int *)jarg3;
73104   arg4 = jarg4 ? true : false;
73105   {
73106     try {
73107       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73108     } catch (std::out_of_range& e) {
73109       {
73110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73111       };
73112     } catch (std::exception& e) {
73113       {
73114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73115       };
73116     } catch (Dali::DaliException e) {
73117       {
73118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73119       };
73120     } catch (...) {
73121       {
73122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73123       };
73124     }
73125   }
73126
73127   jresult = result;
73128   return jresult;
73129 }
73130
73131
73132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73133   unsigned int jresult ;
73134   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73135   float arg2 ;
73136   bool arg3 ;
73137   unsigned int result;
73138
73139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73140   arg2 = (float)jarg2;
73141   arg3 = jarg3 ? true : false;
73142   {
73143     try {
73144       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
73145     } catch (std::out_of_range& e) {
73146       {
73147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73148       };
73149     } catch (std::exception& e) {
73150       {
73151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73152       };
73153     } catch (Dali::DaliException e) {
73154       {
73155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73156       };
73157     } catch (...) {
73158       {
73159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73160       };
73161     }
73162   }
73163
73164   jresult = result;
73165   return jresult;
73166 }
73167
73168
73169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
73170   unsigned int jresult ;
73171   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73172   unsigned int result;
73173
73174   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73175   {
73176     try {
73177       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73178     } catch (std::out_of_range& e) {
73179       {
73180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73181       };
73182     } catch (std::exception& e) {
73183       {
73184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73185       };
73186     } catch (Dali::DaliException e) {
73187       {
73188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73189       };
73190     } catch (...) {
73191       {
73192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73193       };
73194     }
73195   }
73196
73197   jresult = result;
73198   return jresult;
73199 }
73200
73201
73202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73203   int jresult ;
73204   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73205   Dali::Toolkit::Ruler::RulerType result;
73206
73207   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73208   {
73209     try {
73210       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73211     } catch (std::out_of_range& e) {
73212       {
73213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73214       };
73215     } catch (std::exception& e) {
73216       {
73217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (Dali::DaliException e) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73222       };
73223     } catch (...) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73226       };
73227     }
73228   }
73229
73230   jresult = (int)result;
73231   return jresult;
73232 }
73233
73234
73235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73236   unsigned int jresult ;
73237   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73238   bool result;
73239
73240   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73241   {
73242     try {
73243       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
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 void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73270
73271   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73272   {
73273     try {
73274       (arg1)->Enable();
73275     } catch (std::out_of_range& e) {
73276       {
73277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73278       };
73279     } catch (std::exception& e) {
73280       {
73281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73282       };
73283     } catch (Dali::DaliException e) {
73284       {
73285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73286       };
73287     } catch (...) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73290       };
73291     }
73292   }
73293
73294 }
73295
73296
73297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73298   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73299
73300   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73301   {
73302     try {
73303       (arg1)->Disable();
73304     } catch (std::out_of_range& e) {
73305       {
73306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73307       };
73308     } catch (std::exception& e) {
73309       {
73310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73311       };
73312     } catch (Dali::DaliException e) {
73313       {
73314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73315       };
73316     } catch (...) {
73317       {
73318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73319       };
73320     }
73321   }
73322
73323 }
73324
73325
73326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73327   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73328   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73329   Dali::Toolkit::RulerDomain *argp2 ;
73330
73331   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73332   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73333   if (!argp2) {
73334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73335     return ;
73336   }
73337   arg2 = *argp2;
73338   {
73339     try {
73340       (arg1)->SetDomain(arg2);
73341     } catch (std::out_of_range& e) {
73342       {
73343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73344       };
73345     } catch (std::exception& e) {
73346       {
73347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73348       };
73349     } catch (Dali::DaliException e) {
73350       {
73351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73352       };
73353     } catch (...) {
73354       {
73355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73356       };
73357     }
73358   }
73359
73360 }
73361
73362
73363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73364   void * jresult ;
73365   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73366   Dali::Toolkit::RulerDomain *result = 0 ;
73367
73368   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73369   {
73370     try {
73371       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73372     } catch (std::out_of_range& e) {
73373       {
73374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73375       };
73376     } catch (std::exception& e) {
73377       {
73378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73379       };
73380     } catch (Dali::DaliException e) {
73381       {
73382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73383       };
73384     } catch (...) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73387       };
73388     }
73389   }
73390
73391   jresult = (void *)result;
73392   return jresult;
73393 }
73394
73395
73396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73397   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73398
73399   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73400   {
73401     try {
73402       (arg1)->DisableDomain();
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73410       };
73411     } catch (Dali::DaliException e) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73414       };
73415     } catch (...) {
73416       {
73417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73418       };
73419     }
73420   }
73421
73422 }
73423
73424
73425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73426   float jresult ;
73427   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73428   float arg2 ;
73429   float arg3 ;
73430   float arg4 ;
73431   float result;
73432
73433   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73434   arg2 = (float)jarg2;
73435   arg3 = (float)jarg3;
73436   arg4 = (float)jarg4;
73437   {
73438     try {
73439       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73440     } catch (std::out_of_range& e) {
73441       {
73442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73443       };
73444     } catch (std::exception& e) {
73445       {
73446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73447       };
73448     } catch (Dali::DaliException e) {
73449       {
73450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73451       };
73452     } catch (...) {
73453       {
73454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73455       };
73456     }
73457   }
73458
73459   jresult = result;
73460   return jresult;
73461 }
73462
73463
73464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73465   float jresult ;
73466   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73467   float arg2 ;
73468   float arg3 ;
73469   float result;
73470
73471   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73472   arg2 = (float)jarg2;
73473   arg3 = (float)jarg3;
73474   {
73475     try {
73476       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (Dali::DaliException e) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73492       };
73493     }
73494   }
73495
73496   jresult = result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73502   float jresult ;
73503   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73504   float arg2 ;
73505   float result;
73506
73507   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73508   arg2 = (float)jarg2;
73509   {
73510     try {
73511       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73512     } catch (std::out_of_range& e) {
73513       {
73514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73515       };
73516     } catch (std::exception& e) {
73517       {
73518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73519       };
73520     } catch (Dali::DaliException e) {
73521       {
73522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73523       };
73524     } catch (...) {
73525       {
73526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73527       };
73528     }
73529   }
73530
73531   jresult = result;
73532   return jresult;
73533 }
73534
73535
73536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73537   float jresult ;
73538   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73539   float arg2 ;
73540   float arg3 ;
73541   float arg4 ;
73542   Dali::Toolkit::ClampState *arg5 = 0 ;
73543   float result;
73544
73545   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73546   arg2 = (float)jarg2;
73547   arg3 = (float)jarg3;
73548   arg4 = (float)jarg4;
73549   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73550   if (!arg5) {
73551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73552     return 0;
73553   }
73554   {
73555     try {
73556       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73557     } catch (std::out_of_range& e) {
73558       {
73559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73560       };
73561     } catch (std::exception& e) {
73562       {
73563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73564       };
73565     } catch (Dali::DaliException e) {
73566       {
73567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73568       };
73569     } catch (...) {
73570       {
73571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73572       };
73573     }
73574   }
73575
73576   jresult = result;
73577   return jresult;
73578 }
73579
73580
73581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73582   float jresult ;
73583   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73584   float arg2 ;
73585   float arg3 ;
73586   float arg4 ;
73587   float arg5 ;
73588   float result;
73589
73590   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73591   arg2 = (float)jarg2;
73592   arg3 = (float)jarg3;
73593   arg4 = (float)jarg4;
73594   arg5 = (float)jarg5;
73595   {
73596     try {
73597       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73598     } catch (std::out_of_range& e) {
73599       {
73600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73601       };
73602     } catch (std::exception& e) {
73603       {
73604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (Dali::DaliException e) {
73607       {
73608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73609       };
73610     } catch (...) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73613       };
73614     }
73615   }
73616
73617   jresult = result;
73618   return jresult;
73619 }
73620
73621
73622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73623   float jresult ;
73624   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73625   float arg2 ;
73626   float arg3 ;
73627   float arg4 ;
73628   float result;
73629
73630   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73631   arg2 = (float)jarg2;
73632   arg3 = (float)jarg3;
73633   arg4 = (float)jarg4;
73634   {
73635     try {
73636       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73637     } catch (std::out_of_range& e) {
73638       {
73639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73640       };
73641     } catch (std::exception& e) {
73642       {
73643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73644       };
73645     } catch (Dali::DaliException e) {
73646       {
73647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73648       };
73649     } catch (...) {
73650       {
73651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73652       };
73653     }
73654   }
73655
73656   jresult = result;
73657   return jresult;
73658 }
73659
73660
73661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73662   float jresult ;
73663   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73664   float arg2 ;
73665   float arg3 ;
73666   float result;
73667
73668   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73669   arg2 = (float)jarg2;
73670   arg3 = (float)jarg3;
73671   {
73672     try {
73673       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73674     } catch (std::out_of_range& e) {
73675       {
73676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73677       };
73678     } catch (std::exception& e) {
73679       {
73680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73681       };
73682     } catch (Dali::DaliException e) {
73683       {
73684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73685       };
73686     } catch (...) {
73687       {
73688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73689       };
73690     }
73691   }
73692
73693   jresult = result;
73694   return jresult;
73695 }
73696
73697
73698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73699   float jresult ;
73700   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73701   float arg2 ;
73702   float result;
73703
73704   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73705   arg2 = (float)jarg2;
73706   {
73707     try {
73708       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
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_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73734   float jresult ;
73735   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73736   float arg2 ;
73737   float arg3 ;
73738   float arg4 ;
73739   float arg5 ;
73740   Dali::Toolkit::ClampState *arg6 = 0 ;
73741   float result;
73742
73743   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73744   arg2 = (float)jarg2;
73745   arg3 = (float)jarg3;
73746   arg4 = (float)jarg4;
73747   arg5 = (float)jarg5;
73748   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73749   if (!arg6) {
73750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73751     return 0;
73752   }
73753   {
73754     try {
73755       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (Dali::DaliException e) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73767       };
73768     } catch (...) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73771       };
73772     }
73773   }
73774
73775   jresult = result;
73776   return jresult;
73777 }
73778
73779
73780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73781   void * jresult ;
73782   Dali::Toolkit::DefaultRuler *result = 0 ;
73783
73784   {
73785     try {
73786       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73787     } catch (std::out_of_range& e) {
73788       {
73789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73790       };
73791     } catch (std::exception& e) {
73792       {
73793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73794       };
73795     } catch (Dali::DaliException e) {
73796       {
73797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73798       };
73799     } catch (...) {
73800       {
73801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73802       };
73803     }
73804   }
73805
73806   jresult = (void *)result;
73807   return jresult;
73808 }
73809
73810
73811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73812   float jresult ;
73813   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73814   float arg2 ;
73815   float arg3 ;
73816   float result;
73817
73818   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73819   arg2 = (float)jarg2;
73820   arg3 = (float)jarg3;
73821   {
73822     try {
73823       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73824     } catch (std::out_of_range& e) {
73825       {
73826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73827       };
73828     } catch (std::exception& e) {
73829       {
73830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73831       };
73832     } catch (Dali::DaliException e) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73835       };
73836     } catch (...) {
73837       {
73838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73839       };
73840     }
73841   }
73842
73843   jresult = result;
73844   return jresult;
73845 }
73846
73847
73848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73849   float jresult ;
73850   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73851   unsigned int arg2 ;
73852   unsigned int *arg3 = 0 ;
73853   bool arg4 ;
73854   float result;
73855
73856   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73857   arg2 = (unsigned int)jarg2;
73858   arg3 = (unsigned int *)jarg3;
73859   arg4 = jarg4 ? true : false;
73860   {
73861     try {
73862       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73863     } catch (std::out_of_range& e) {
73864       {
73865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73866       };
73867     } catch (std::exception& e) {
73868       {
73869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73870       };
73871     } catch (Dali::DaliException e) {
73872       {
73873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73874       };
73875     } catch (...) {
73876       {
73877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73878       };
73879     }
73880   }
73881
73882   jresult = result;
73883   return jresult;
73884 }
73885
73886
73887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73888   unsigned int jresult ;
73889   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73890   float arg2 ;
73891   bool arg3 ;
73892   unsigned int result;
73893
73894   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73895   arg2 = (float)jarg2;
73896   arg3 = jarg3 ? true : false;
73897   {
73898     try {
73899       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73900     } catch (std::out_of_range& e) {
73901       {
73902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73903       };
73904     } catch (std::exception& e) {
73905       {
73906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73907       };
73908     } catch (Dali::DaliException e) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73911       };
73912     } catch (...) {
73913       {
73914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73915       };
73916     }
73917   }
73918
73919   jresult = result;
73920   return jresult;
73921 }
73922
73923
73924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73925   unsigned int jresult ;
73926   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73927   unsigned int result;
73928
73929   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73930   {
73931     try {
73932       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73933     } catch (std::out_of_range& e) {
73934       {
73935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73936       };
73937     } catch (std::exception& e) {
73938       {
73939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73940       };
73941     } catch (Dali::DaliException e) {
73942       {
73943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73944       };
73945     } catch (...) {
73946       {
73947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73948       };
73949     }
73950   }
73951
73952   jresult = result;
73953   return jresult;
73954 }
73955
73956
73957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73958   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73959
73960   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73961   {
73962     try {
73963       delete arg1;
73964     } catch (std::out_of_range& e) {
73965       {
73966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73967       };
73968     } catch (std::exception& e) {
73969       {
73970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73971       };
73972     } catch (Dali::DaliException e) {
73973       {
73974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73975       };
73976     } catch (...) {
73977       {
73978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73979       };
73980     }
73981   }
73982
73983 }
73984
73985
73986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73987   void * jresult ;
73988   float arg1 ;
73989   Dali::Toolkit::FixedRuler *result = 0 ;
73990
73991   arg1 = (float)jarg1;
73992   {
73993     try {
73994       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73995     } catch (std::out_of_range& e) {
73996       {
73997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73998       };
73999     } catch (std::exception& e) {
74000       {
74001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74002       };
74003     } catch (Dali::DaliException e) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74006       };
74007     } catch (...) {
74008       {
74009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74010       };
74011     }
74012   }
74013
74014   jresult = (void *)result;
74015   return jresult;
74016 }
74017
74018
74019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
74020   void * jresult ;
74021   Dali::Toolkit::FixedRuler *result = 0 ;
74022
74023   {
74024     try {
74025       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
74026     } catch (std::out_of_range& e) {
74027       {
74028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74029       };
74030     } catch (std::exception& e) {
74031       {
74032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74033       };
74034     } catch (Dali::DaliException e) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74037       };
74038     } catch (...) {
74039       {
74040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74041       };
74042     }
74043   }
74044
74045   jresult = (void *)result;
74046   return jresult;
74047 }
74048
74049
74050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
74051   float jresult ;
74052   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74053   float arg2 ;
74054   float arg3 ;
74055   float result;
74056
74057   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74058   arg2 = (float)jarg2;
74059   arg3 = (float)jarg3;
74060   {
74061     try {
74062       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
74063     } catch (std::out_of_range& e) {
74064       {
74065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74066       };
74067     } catch (std::exception& e) {
74068       {
74069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74070       };
74071     } catch (Dali::DaliException e) {
74072       {
74073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74074       };
74075     } catch (...) {
74076       {
74077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74078       };
74079     }
74080   }
74081
74082   jresult = result;
74083   return jresult;
74084 }
74085
74086
74087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74088   float jresult ;
74089   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74090   unsigned int arg2 ;
74091   unsigned int *arg3 = 0 ;
74092   bool arg4 ;
74093   float result;
74094
74095   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74096   arg2 = (unsigned int)jarg2;
74097   arg3 = (unsigned int *)jarg3;
74098   arg4 = jarg4 ? true : false;
74099   {
74100     try {
74101       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74102     } catch (std::out_of_range& e) {
74103       {
74104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74105       };
74106     } catch (std::exception& e) {
74107       {
74108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (Dali::DaliException e) {
74111       {
74112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74113       };
74114     } catch (...) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74117       };
74118     }
74119   }
74120
74121   jresult = result;
74122   return jresult;
74123 }
74124
74125
74126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74127   unsigned int jresult ;
74128   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74129   float arg2 ;
74130   bool arg3 ;
74131   unsigned int result;
74132
74133   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74134   arg2 = (float)jarg2;
74135   arg3 = jarg3 ? true : false;
74136   {
74137     try {
74138       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (Dali::DaliException e) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74150       };
74151     } catch (...) {
74152       {
74153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74154       };
74155     }
74156   }
74157
74158   jresult = result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
74164   unsigned int jresult ;
74165   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74166   unsigned int result;
74167
74168   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74169   {
74170     try {
74171       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
74172     } catch (std::out_of_range& e) {
74173       {
74174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74175       };
74176     } catch (std::exception& e) {
74177       {
74178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74179       };
74180     } catch (Dali::DaliException e) {
74181       {
74182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74183       };
74184     } catch (...) {
74185       {
74186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74187       };
74188     }
74189   }
74190
74191   jresult = result;
74192   return jresult;
74193 }
74194
74195
74196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74197   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74198
74199   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74200   {
74201     try {
74202       delete arg1;
74203     } catch (std::out_of_range& e) {
74204       {
74205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74206       };
74207     } catch (std::exception& e) {
74208       {
74209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74210       };
74211     } catch (Dali::DaliException e) {
74212       {
74213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74214       };
74215     } catch (...) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74218       };
74219     }
74220   }
74221
74222 }
74223
74224
74225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74226   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74227   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74228
74229   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74230   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74231   if (arg1) (arg1)->scale = *arg2;
74232 }
74233
74234
74235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74236   void * jresult ;
74237   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74238   Dali::Toolkit::ClampState2D *result = 0 ;
74239
74240   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74241   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74242   jresult = (void *)result;
74243   return jresult;
74244 }
74245
74246
74247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74248   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74249   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74250
74251   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74252   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74253   if (arg1) (arg1)->position = *arg2;
74254 }
74255
74256
74257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74258   void * jresult ;
74259   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74260   Dali::Toolkit::ClampState2D *result = 0 ;
74261
74262   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74263   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74264   jresult = (void *)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74270   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74271   Dali::Toolkit::ClampState arg2 ;
74272
74273   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74274   arg2 = (Dali::Toolkit::ClampState)jarg2;
74275   if (arg1) (arg1)->rotation = arg2;
74276 }
74277
74278
74279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74280   int jresult ;
74281   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74282   Dali::Toolkit::ClampState result;
74283
74284   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74285   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74286   jresult = (int)result;
74287   return jresult;
74288 }
74289
74290
74291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74292   void * jresult ;
74293   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74294
74295   {
74296     try {
74297       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74298     } catch (std::out_of_range& e) {
74299       {
74300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74301       };
74302     } catch (std::exception& e) {
74303       {
74304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74305       };
74306     } catch (Dali::DaliException e) {
74307       {
74308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74309       };
74310     } catch (...) {
74311       {
74312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74313       };
74314     }
74315   }
74316
74317   jresult = (void *)result;
74318   return jresult;
74319 }
74320
74321
74322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74323   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74324
74325   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74326   {
74327     try {
74328       delete arg1;
74329     } catch (std::out_of_range& e) {
74330       {
74331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74332       };
74333     } catch (std::exception& e) {
74334       {
74335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74336       };
74337     } catch (Dali::DaliException e) {
74338       {
74339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74340       };
74341     } catch (...) {
74342       {
74343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74344       };
74345     }
74346   }
74347
74348 }
74349
74350
74351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74352   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74353   Dali::Toolkit::SnapType arg2 ;
74354
74355   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74356   arg2 = (Dali::Toolkit::SnapType)jarg2;
74357   if (arg1) (arg1)->type = arg2;
74358 }
74359
74360
74361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74362   int jresult ;
74363   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74364   Dali::Toolkit::SnapType result;
74365
74366   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74367   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74368   jresult = (int)result;
74369   return jresult;
74370 }
74371
74372
74373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74374   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74375   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74376
74377   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74378   arg2 = (Dali::Vector2 *)jarg2;
74379   if (arg1) (arg1)->position = *arg2;
74380 }
74381
74382
74383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74384   void * jresult ;
74385   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74386   Dali::Vector2 *result = 0 ;
74387
74388   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74389   result = (Dali::Vector2 *)& ((arg1)->position);
74390   jresult = (void *)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74396   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74397   float arg2 ;
74398
74399   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74400   arg2 = (float)jarg2;
74401   if (arg1) (arg1)->duration = arg2;
74402 }
74403
74404
74405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74406   float jresult ;
74407   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74408   float result;
74409
74410   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74411   result = (float) ((arg1)->duration);
74412   jresult = result;
74413   return jresult;
74414 }
74415
74416
74417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74418   void * jresult ;
74419   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74420
74421   {
74422     try {
74423       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74424     } catch (std::out_of_range& e) {
74425       {
74426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74427       };
74428     } catch (std::exception& e) {
74429       {
74430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74431       };
74432     } catch (Dali::DaliException e) {
74433       {
74434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74435       };
74436     } catch (...) {
74437       {
74438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74439       };
74440     }
74441   }
74442
74443   jresult = (void *)result;
74444   return jresult;
74445 }
74446
74447
74448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74449   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74450
74451   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74452   {
74453     try {
74454       delete arg1;
74455     } catch (std::out_of_range& e) {
74456       {
74457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74458       };
74459     } catch (std::exception& e) {
74460       {
74461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74462       };
74463     } catch (Dali::DaliException e) {
74464       {
74465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74466       };
74467     } catch (...) {
74468       {
74469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74470       };
74471     }
74472   }
74473
74474 }
74475
74476
74477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74478   int jresult ;
74479   int result;
74480
74481   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74482   jresult = (int)result;
74483   return jresult;
74484 }
74485
74486
74487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74488   int jresult ;
74489   int result;
74490
74491   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74492   jresult = (int)result;
74493   return jresult;
74494 }
74495
74496
74497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74498   int jresult ;
74499   int result;
74500
74501   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74502   jresult = (int)result;
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74508   int jresult ;
74509   int result;
74510
74511   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74512   jresult = (int)result;
74513   return jresult;
74514 }
74515
74516
74517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74518   int jresult ;
74519   int result;
74520
74521   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74522   jresult = (int)result;
74523   return jresult;
74524 }
74525
74526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74527   int jresult ;
74528   int result;
74529
74530   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74531   jresult = (int)result;
74532   return jresult;
74533 }
74534
74535
74536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74537   int jresult ;
74538   int result;
74539
74540   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74541   jresult = (int)result;
74542   return jresult;
74543 }
74544
74545
74546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74547   int jresult ;
74548   int result;
74549
74550   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74551   jresult = (int)result;
74552   return jresult;
74553 }
74554
74555
74556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74557   int jresult ;
74558   int result;
74559
74560   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74561   jresult = (int)result;
74562   return jresult;
74563 }
74564
74565
74566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74567   int jresult ;
74568   int result;
74569
74570   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74571   jresult = (int)result;
74572   return jresult;
74573 }
74574
74575
74576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74577   int jresult ;
74578   int result;
74579
74580   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74581   jresult = (int)result;
74582   return jresult;
74583 }
74584
74585
74586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74587   int jresult ;
74588   int result;
74589
74590   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74591   jresult = (int)result;
74592   return jresult;
74593 }
74594
74595
74596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74597   int jresult ;
74598   int result;
74599
74600   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74601   jresult = (int)result;
74602   return jresult;
74603 }
74604
74605
74606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74607   int jresult ;
74608   int result;
74609
74610   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74611   jresult = (int)result;
74612   return jresult;
74613 }
74614
74615
74616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74617   int jresult ;
74618   int result;
74619
74620   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74621   jresult = (int)result;
74622   return jresult;
74623 }
74624
74625
74626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74627   int jresult ;
74628   int result;
74629
74630   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74631   jresult = (int)result;
74632   return jresult;
74633 }
74634
74635
74636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74637   int jresult ;
74638   int result;
74639
74640   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74641   jresult = (int)result;
74642   return jresult;
74643 }
74644
74645
74646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74647   int jresult ;
74648   int result;
74649
74650   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74651   jresult = (int)result;
74652   return jresult;
74653 }
74654
74655
74656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74657   int jresult ;
74658   int result;
74659
74660   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74661   jresult = (int)result;
74662   return jresult;
74663 }
74664
74665
74666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74667   int jresult ;
74668   int result;
74669
74670   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74671   jresult = (int)result;
74672   return jresult;
74673 }
74674
74675
74676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74677   int jresult ;
74678   int result;
74679
74680   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74681   jresult = (int)result;
74682   return jresult;
74683 }
74684
74685
74686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74687   int jresult ;
74688   int result;
74689
74690   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74691   jresult = (int)result;
74692   return jresult;
74693 }
74694
74695
74696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74697   int jresult ;
74698   int result;
74699
74700   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74701   jresult = (int)result;
74702   return jresult;
74703 }
74704
74705
74706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74707   int jresult ;
74708   int result;
74709
74710   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74711   jresult = (int)result;
74712   return jresult;
74713 }
74714
74715
74716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74717   int jresult ;
74718   int result;
74719
74720   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74721   jresult = (int)result;
74722   return jresult;
74723 }
74724
74725
74726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74727   int jresult ;
74728   int result;
74729
74730   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74731   jresult = (int)result;
74732   return jresult;
74733 }
74734
74735
74736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74737   void * jresult ;
74738   Dali::Toolkit::ScrollView::Property *result = 0 ;
74739
74740   {
74741     try {
74742       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74743     } catch (std::out_of_range& e) {
74744       {
74745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74746       };
74747     } catch (std::exception& e) {
74748       {
74749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (Dali::DaliException e) {
74752       {
74753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74754       };
74755     } catch (...) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74758       };
74759     }
74760   }
74761
74762   jresult = (void *)result;
74763   return jresult;
74764 }
74765
74766
74767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74768   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74769
74770   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74771   {
74772     try {
74773       delete arg1;
74774     } catch (std::out_of_range& e) {
74775       {
74776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74777       };
74778     } catch (std::exception& e) {
74779       {
74780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74781       };
74782     } catch (Dali::DaliException e) {
74783       {
74784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74785       };
74786     } catch (...) {
74787       {
74788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74789       };
74790     }
74791   }
74792
74793 }
74794
74795
74796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74797   void * jresult ;
74798   Dali::Toolkit::ScrollView *result = 0 ;
74799
74800   {
74801     try {
74802       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74803     } catch (std::out_of_range& e) {
74804       {
74805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74806       };
74807     } catch (std::exception& e) {
74808       {
74809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74810       };
74811     } catch (Dali::DaliException e) {
74812       {
74813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74814       };
74815     } catch (...) {
74816       {
74817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74818       };
74819     }
74820   }
74821
74822   jresult = (void *)result;
74823   return jresult;
74824 }
74825
74826
74827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74828   void * jresult ;
74829   Dali::Toolkit::ScrollView *arg1 = 0 ;
74830   Dali::Toolkit::ScrollView *result = 0 ;
74831
74832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74833   if (!arg1) {
74834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74835     return 0;
74836   }
74837   {
74838     try {
74839       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74840     } catch (std::out_of_range& e) {
74841       {
74842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74843       };
74844     } catch (std::exception& e) {
74845       {
74846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74847       };
74848     } catch (Dali::DaliException e) {
74849       {
74850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74851       };
74852     } catch (...) {
74853       {
74854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74855       };
74856     }
74857   }
74858
74859   jresult = (void *)result;
74860   return jresult;
74861 }
74862
74863
74864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74865   void * jresult ;
74866   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74867   Dali::Toolkit::ScrollView *arg2 = 0 ;
74868   Dali::Toolkit::ScrollView *result = 0 ;
74869
74870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74871   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74872   if (!arg2) {
74873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74874     return 0;
74875   }
74876   {
74877     try {
74878       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74879     } catch (std::out_of_range& e) {
74880       {
74881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74882       };
74883     } catch (std::exception& e) {
74884       {
74885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74886       };
74887     } catch (Dali::DaliException e) {
74888       {
74889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74890       };
74891     } catch (...) {
74892       {
74893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74894       };
74895     }
74896   }
74897
74898   jresult = (void *)result;
74899   return jresult;
74900 }
74901
74902
74903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74904   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74905
74906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74907   {
74908     try {
74909       delete arg1;
74910     } catch (std::out_of_range& e) {
74911       {
74912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74913       };
74914     } catch (std::exception& e) {
74915       {
74916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74917       };
74918     } catch (Dali::DaliException e) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74921       };
74922     } catch (...) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74925       };
74926     }
74927   }
74928
74929 }
74930
74931
74932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74933   void * jresult ;
74934   Dali::Toolkit::ScrollView result;
74935
74936   {
74937     try {
74938       result = Dali::Toolkit::ScrollView::New();
74939     } catch (std::out_of_range& e) {
74940       {
74941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74942       };
74943     } catch (std::exception& e) {
74944       {
74945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (Dali::DaliException e) {
74948       {
74949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74950       };
74951     } catch (...) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74954       };
74955     }
74956   }
74957
74958   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74959   return jresult;
74960 }
74961
74962
74963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74964   void * jresult ;
74965   Dali::BaseHandle arg1 ;
74966   Dali::BaseHandle *argp1 ;
74967   Dali::Toolkit::ScrollView result;
74968
74969   argp1 = (Dali::BaseHandle *)jarg1;
74970   if (!argp1) {
74971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74972     return 0;
74973   }
74974   arg1 = *argp1;
74975   {
74976     try {
74977       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74978     } catch (std::out_of_range& e) {
74979       {
74980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74981       };
74982     } catch (std::exception& e) {
74983       {
74984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74985       };
74986     } catch (Dali::DaliException e) {
74987       {
74988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74989       };
74990     } catch (...) {
74991       {
74992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74993       };
74994     }
74995   }
74996
74997   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74998   return jresult;
74999 }
75000
75001
75002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
75003   void * jresult ;
75004   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75005   Dali::AlphaFunction result;
75006
75007   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75008   {
75009     try {
75010       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
75011     } catch (std::out_of_range& e) {
75012       {
75013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75014       };
75015     } catch (std::exception& e) {
75016       {
75017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75018       };
75019     } catch (Dali::DaliException e) {
75020       {
75021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75022       };
75023     } catch (...) {
75024       {
75025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75026       };
75027     }
75028   }
75029
75030   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75031   return jresult;
75032 }
75033
75034
75035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
75036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75037   Dali::AlphaFunction arg2 ;
75038   Dali::AlphaFunction *argp2 ;
75039
75040   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75041   argp2 = (Dali::AlphaFunction *)jarg2;
75042   if (!argp2) {
75043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75044     return ;
75045   }
75046   arg2 = *argp2;
75047   {
75048     try {
75049       (arg1)->SetScrollSnapAlphaFunction(arg2);
75050     } catch (std::out_of_range& e) {
75051       {
75052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75053       };
75054     } catch (std::exception& e) {
75055       {
75056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75057       };
75058     } catch (Dali::DaliException e) {
75059       {
75060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75061       };
75062     } catch (...) {
75063       {
75064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75065       };
75066     }
75067   }
75068
75069 }
75070
75071
75072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
75073   void * jresult ;
75074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75075   Dali::AlphaFunction result;
75076
75077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75078   {
75079     try {
75080       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
75081     } catch (std::out_of_range& e) {
75082       {
75083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75084       };
75085     } catch (std::exception& e) {
75086       {
75087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75088       };
75089     } catch (Dali::DaliException e) {
75090       {
75091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75092       };
75093     } catch (...) {
75094       {
75095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75096       };
75097     }
75098   }
75099
75100   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75101   return jresult;
75102 }
75103
75104
75105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
75106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75107   Dali::AlphaFunction arg2 ;
75108   Dali::AlphaFunction *argp2 ;
75109
75110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75111   argp2 = (Dali::AlphaFunction *)jarg2;
75112   if (!argp2) {
75113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75114     return ;
75115   }
75116   arg2 = *argp2;
75117   {
75118     try {
75119       (arg1)->SetScrollFlickAlphaFunction(arg2);
75120     } catch (std::out_of_range& e) {
75121       {
75122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75123       };
75124     } catch (std::exception& e) {
75125       {
75126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75127       };
75128     } catch (Dali::DaliException e) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75131       };
75132     } catch (...) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75135       };
75136     }
75137   }
75138
75139 }
75140
75141
75142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
75143   float jresult ;
75144   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75145   float result;
75146
75147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75148   {
75149     try {
75150       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
75151     } catch (std::out_of_range& e) {
75152       {
75153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75154       };
75155     } catch (std::exception& e) {
75156       {
75157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75158       };
75159     } catch (Dali::DaliException e) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75162       };
75163     } catch (...) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75166       };
75167     }
75168   }
75169
75170   jresult = result;
75171   return jresult;
75172 }
75173
75174
75175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
75176   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75177   float arg2 ;
75178
75179   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75180   arg2 = (float)jarg2;
75181   {
75182     try {
75183       (arg1)->SetScrollSnapDuration(arg2);
75184     } catch (std::out_of_range& e) {
75185       {
75186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75187       };
75188     } catch (std::exception& e) {
75189       {
75190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75191       };
75192     } catch (Dali::DaliException e) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75199       };
75200     }
75201   }
75202
75203 }
75204
75205
75206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75207   float jresult ;
75208   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75209   float result;
75210
75211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75212   {
75213     try {
75214       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75215     } catch (std::out_of_range& e) {
75216       {
75217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (std::exception& e) {
75220       {
75221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (Dali::DaliException e) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233
75234   jresult = result;
75235   return jresult;
75236 }
75237
75238
75239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75241   float arg2 ;
75242
75243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75244   arg2 = (float)jarg2;
75245   {
75246     try {
75247       (arg1)->SetScrollFlickDuration(arg2);
75248     } catch (std::out_of_range& e) {
75249       {
75250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75251       };
75252     } catch (std::exception& e) {
75253       {
75254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75255       };
75256     } catch (Dali::DaliException e) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75259       };
75260     } catch (...) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75263       };
75264     }
75265   }
75266
75267 }
75268
75269
75270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75272   Dali::Toolkit::RulerPtr arg2 ;
75273   Dali::Toolkit::RulerPtr *argp2 ;
75274
75275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75276   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75277   if (!argp2) {
75278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75279     return ;
75280   }
75281   arg2 = *argp2;
75282   {
75283     try {
75284       (arg1)->SetRulerX(arg2);
75285     } catch (std::out_of_range& e) {
75286       {
75287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75288       };
75289     } catch (std::exception& e) {
75290       {
75291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75292       };
75293     } catch (Dali::DaliException e) {
75294       {
75295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75296       };
75297     } catch (...) {
75298       {
75299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75300       };
75301     }
75302   }
75303
75304 }
75305
75306
75307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75308   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75309   Dali::Toolkit::RulerPtr arg2 ;
75310   Dali::Toolkit::RulerPtr *argp2 ;
75311
75312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75313   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75314   if (!argp2) {
75315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75316     return ;
75317   }
75318   arg2 = *argp2;
75319   {
75320     try {
75321       (arg1)->SetRulerY(arg2);
75322     } catch (std::out_of_range& e) {
75323       {
75324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75325       };
75326     } catch (std::exception& e) {
75327       {
75328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75329       };
75330     } catch (Dali::DaliException e) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75337       };
75338     }
75339   }
75340
75341 }
75342
75343
75344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75346   bool arg2 ;
75347
75348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75349   arg2 = jarg2 ? true : false;
75350   {
75351     try {
75352       (arg1)->SetScrollSensitive(arg2);
75353     } catch (std::out_of_range& e) {
75354       {
75355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75356       };
75357     } catch (std::exception& e) {
75358       {
75359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75360       };
75361     } catch (Dali::DaliException e) {
75362       {
75363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75364       };
75365     } catch (...) {
75366       {
75367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75368       };
75369     }
75370   }
75371
75372 }
75373
75374
75375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75377   float arg2 ;
75378   float arg3 ;
75379
75380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75381   arg2 = (float)jarg2;
75382   arg3 = (float)jarg3;
75383   {
75384     try {
75385       (arg1)->SetMaxOvershoot(arg2,arg3);
75386     } catch (std::out_of_range& e) {
75387       {
75388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75389       };
75390     } catch (std::exception& e) {
75391       {
75392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75393       };
75394     } catch (Dali::DaliException e) {
75395       {
75396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75397       };
75398     } catch (...) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75401       };
75402     }
75403   }
75404
75405 }
75406
75407
75408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75410   Dali::AlphaFunction arg2 ;
75411   Dali::AlphaFunction *argp2 ;
75412
75413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75414   argp2 = (Dali::AlphaFunction *)jarg2;
75415   if (!argp2) {
75416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75417     return ;
75418   }
75419   arg2 = *argp2;
75420   {
75421     try {
75422       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75423     } catch (std::out_of_range& e) {
75424       {
75425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75426       };
75427     } catch (std::exception& e) {
75428       {
75429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75430       };
75431     } catch (Dali::DaliException e) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75434       };
75435     } catch (...) {
75436       {
75437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75438       };
75439     }
75440   }
75441
75442 }
75443
75444
75445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75447   float arg2 ;
75448
75449   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75450   arg2 = (float)jarg2;
75451   {
75452     try {
75453       (arg1)->SetSnapOvershootDuration(arg2);
75454     } catch (std::out_of_range& e) {
75455       {
75456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75457       };
75458     } catch (std::exception& e) {
75459       {
75460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75461       };
75462     } catch (Dali::DaliException e) {
75463       {
75464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75465       };
75466     } catch (...) {
75467       {
75468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75469       };
75470     }
75471   }
75472
75473 }
75474
75475
75476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75478   bool arg2 ;
75479
75480   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75481   arg2 = jarg2 ? true : false;
75482   {
75483     try {
75484       (arg1)->SetActorAutoSnap(arg2);
75485     } catch (std::out_of_range& e) {
75486       {
75487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75488       };
75489     } catch (std::exception& e) {
75490       {
75491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75492       };
75493     } catch (Dali::DaliException e) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75496       };
75497     } catch (...) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75500       };
75501     }
75502   }
75503
75504 }
75505
75506
75507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75508   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75509   bool arg2 ;
75510
75511   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75512   arg2 = jarg2 ? true : false;
75513   {
75514     try {
75515       (arg1)->SetWrapMode(arg2);
75516     } catch (std::out_of_range& e) {
75517       {
75518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75519       };
75520     } catch (std::exception& e) {
75521       {
75522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75523       };
75524     } catch (Dali::DaliException e) {
75525       {
75526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75527       };
75528     } catch (...) {
75529       {
75530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75531       };
75532     }
75533   }
75534
75535 }
75536
75537
75538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75539   int jresult ;
75540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75541   int result;
75542
75543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75544   {
75545     try {
75546       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75547     } catch (std::out_of_range& e) {
75548       {
75549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75550       };
75551     } catch (std::exception& e) {
75552       {
75553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75554       };
75555     } catch (Dali::DaliException e) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75558       };
75559     } catch (...) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75562       };
75563     }
75564   }
75565
75566   jresult = result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75573   int arg2 ;
75574
75575   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75576   arg2 = (int)jarg2;
75577   {
75578     try {
75579       (arg1)->SetScrollUpdateDistance(arg2);
75580     } catch (std::out_of_range& e) {
75581       {
75582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75583       };
75584     } catch (std::exception& e) {
75585       {
75586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75587       };
75588     } catch (Dali::DaliException e) {
75589       {
75590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75591       };
75592     } catch (...) {
75593       {
75594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75595       };
75596     }
75597   }
75598
75599 }
75600
75601
75602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75603   unsigned int jresult ;
75604   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75605   bool result;
75606
75607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75608   {
75609     try {
75610       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75611     } catch (std::out_of_range& e) {
75612       {
75613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75614       };
75615     } catch (std::exception& e) {
75616       {
75617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75618       };
75619     } catch (Dali::DaliException e) {
75620       {
75621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75622       };
75623     } catch (...) {
75624       {
75625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75626       };
75627     }
75628   }
75629
75630   jresult = result;
75631   return jresult;
75632 }
75633
75634
75635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75636   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75637   bool arg2 ;
75638
75639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75640   arg2 = jarg2 ? true : false;
75641   {
75642     try {
75643       (arg1)->SetAxisAutoLock(arg2);
75644     } catch (std::out_of_range& e) {
75645       {
75646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75647       };
75648     } catch (std::exception& e) {
75649       {
75650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75651       };
75652     } catch (Dali::DaliException e) {
75653       {
75654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75655       };
75656     } catch (...) {
75657       {
75658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75659       };
75660     }
75661   }
75662
75663 }
75664
75665
75666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75667   float jresult ;
75668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75669   float result;
75670
75671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75672   {
75673     try {
75674       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75675     } catch (std::out_of_range& e) {
75676       {
75677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75678       };
75679     } catch (std::exception& e) {
75680       {
75681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75682       };
75683     } catch (Dali::DaliException e) {
75684       {
75685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75686       };
75687     } catch (...) {
75688       {
75689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75690       };
75691     }
75692   }
75693
75694   jresult = result;
75695   return jresult;
75696 }
75697
75698
75699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75700   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75701   float arg2 ;
75702
75703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75704   arg2 = (float)jarg2;
75705   {
75706     try {
75707       (arg1)->SetAxisAutoLockGradient(arg2);
75708     } catch (std::out_of_range& e) {
75709       {
75710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75711       };
75712     } catch (std::exception& e) {
75713       {
75714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75715       };
75716     } catch (Dali::DaliException e) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75719       };
75720     } catch (...) {
75721       {
75722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75723       };
75724     }
75725   }
75726
75727 }
75728
75729
75730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75731   float jresult ;
75732   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75733   float result;
75734
75735   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75736   {
75737     try {
75738       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75739     } catch (std::out_of_range& e) {
75740       {
75741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75742       };
75743     } catch (std::exception& e) {
75744       {
75745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75746       };
75747     } catch (Dali::DaliException e) {
75748       {
75749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75750       };
75751     } catch (...) {
75752       {
75753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75754       };
75755     }
75756   }
75757
75758   jresult = result;
75759   return jresult;
75760 }
75761
75762
75763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75765   float arg2 ;
75766
75767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75768   arg2 = (float)jarg2;
75769   {
75770     try {
75771       (arg1)->SetFrictionCoefficient(arg2);
75772     } catch (std::out_of_range& e) {
75773       {
75774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75775       };
75776     } catch (std::exception& e) {
75777       {
75778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75779       };
75780     } catch (Dali::DaliException e) {
75781       {
75782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75783       };
75784     } catch (...) {
75785       {
75786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75787       };
75788     }
75789   }
75790
75791 }
75792
75793
75794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75795   float jresult ;
75796   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75797   float result;
75798
75799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75800   {
75801     try {
75802       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75810       };
75811     } catch (Dali::DaliException e) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75814       };
75815     } catch (...) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75818       };
75819     }
75820   }
75821
75822   jresult = result;
75823   return jresult;
75824 }
75825
75826
75827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75829   float arg2 ;
75830
75831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75832   arg2 = (float)jarg2;
75833   {
75834     try {
75835       (arg1)->SetFlickSpeedCoefficient(arg2);
75836     } catch (std::out_of_range& e) {
75837       {
75838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75839       };
75840     } catch (std::exception& e) {
75841       {
75842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75843       };
75844     } catch (Dali::DaliException e) {
75845       {
75846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75847       };
75848     } catch (...) {
75849       {
75850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75851       };
75852     }
75853   }
75854
75855 }
75856
75857
75858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75859   void * jresult ;
75860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75861   Dali::Vector2 result;
75862
75863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75864   {
75865     try {
75866       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75867     } catch (std::out_of_range& e) {
75868       {
75869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75870       };
75871     } catch (std::exception& e) {
75872       {
75873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75874       };
75875     } catch (Dali::DaliException e) {
75876       {
75877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75878       };
75879     } catch (...) {
75880       {
75881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75882       };
75883     }
75884   }
75885
75886   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75887   return jresult;
75888 }
75889
75890
75891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75892   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75893   Dali::Vector2 *arg2 = 0 ;
75894
75895   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75896   arg2 = (Dali::Vector2 *)jarg2;
75897   if (!arg2) {
75898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75899     return ;
75900   }
75901   {
75902     try {
75903       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75904     } catch (std::out_of_range& e) {
75905       {
75906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75907       };
75908     } catch (std::exception& e) {
75909       {
75910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75911       };
75912     } catch (Dali::DaliException e) {
75913       {
75914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75915       };
75916     } catch (...) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75919       };
75920     }
75921   }
75922
75923 }
75924
75925
75926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75927   float jresult ;
75928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75929   float result;
75930
75931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75932   {
75933     try {
75934       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75942       };
75943     } catch (Dali::DaliException e) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75946       };
75947     } catch (...) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75950       };
75951     }
75952   }
75953
75954   jresult = result;
75955   return jresult;
75956 }
75957
75958
75959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75960   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75961   float arg2 ;
75962
75963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75964   arg2 = (float)jarg2;
75965   {
75966     try {
75967       (arg1)->SetMinimumSpeedForFlick(arg2);
75968     } catch (std::out_of_range& e) {
75969       {
75970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75971       };
75972     } catch (std::exception& e) {
75973       {
75974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75975       };
75976     } catch (Dali::DaliException e) {
75977       {
75978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75979       };
75980     } catch (...) {
75981       {
75982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75983       };
75984     }
75985   }
75986
75987 }
75988
75989
75990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75991   float jresult ;
75992   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75993   float result;
75994
75995   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75996   {
75997     try {
75998       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75999     } catch (std::out_of_range& e) {
76000       {
76001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76002       };
76003     } catch (std::exception& e) {
76004       {
76005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76006       };
76007     } catch (Dali::DaliException e) {
76008       {
76009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76010       };
76011     } catch (...) {
76012       {
76013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76014       };
76015     }
76016   }
76017
76018   jresult = result;
76019   return jresult;
76020 }
76021
76022
76023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
76024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76025   float arg2 ;
76026
76027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76028   arg2 = (float)jarg2;
76029   {
76030     try {
76031       (arg1)->SetMaxFlickSpeed(arg2);
76032     } catch (std::out_of_range& e) {
76033       {
76034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76035       };
76036     } catch (std::exception& e) {
76037       {
76038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76039       };
76040     } catch (Dali::DaliException e) {
76041       {
76042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76043       };
76044     } catch (...) {
76045       {
76046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76047       };
76048     }
76049   }
76050
76051 }
76052
76053
76054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
76055   void * jresult ;
76056   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76057   Dali::Vector2 result;
76058
76059   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76060   {
76061     try {
76062       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
76063     } catch (std::out_of_range& e) {
76064       {
76065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76066       };
76067     } catch (std::exception& e) {
76068       {
76069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76070       };
76071     } catch (Dali::DaliException e) {
76072       {
76073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76074       };
76075     } catch (...) {
76076       {
76077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76078       };
76079     }
76080   }
76081
76082   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76083   return jresult;
76084 }
76085
76086
76087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
76088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76089   Dali::Vector2 arg2 ;
76090   Dali::Vector2 *argp2 ;
76091
76092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76093   argp2 = (Dali::Vector2 *)jarg2;
76094   if (!argp2) {
76095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
76096     return ;
76097   }
76098   arg2 = *argp2;
76099   {
76100     try {
76101       (arg1)->SetWheelScrollDistanceStep(arg2);
76102     } catch (std::out_of_range& e) {
76103       {
76104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76105       };
76106     } catch (std::exception& e) {
76107       {
76108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76109       };
76110     } catch (Dali::DaliException e) {
76111       {
76112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76113       };
76114     } catch (...) {
76115       {
76116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76117       };
76118     }
76119   }
76120
76121 }
76122
76123
76124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
76125   void * jresult ;
76126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76127   Dali::Vector2 result;
76128
76129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76130   {
76131     try {
76132       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
76133     } catch (std::out_of_range& e) {
76134       {
76135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76136       };
76137     } catch (std::exception& e) {
76138       {
76139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76140       };
76141     } catch (Dali::DaliException e) {
76142       {
76143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76144       };
76145     } catch (...) {
76146       {
76147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76148       };
76149     }
76150   }
76151
76152   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76153   return jresult;
76154 }
76155
76156
76157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
76158   unsigned int jresult ;
76159   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76160   unsigned int result;
76161
76162   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76163   {
76164     try {
76165       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
76166     } catch (std::out_of_range& e) {
76167       {
76168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76169       };
76170     } catch (std::exception& e) {
76171       {
76172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76173       };
76174     } catch (Dali::DaliException e) {
76175       {
76176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76177       };
76178     } catch (...) {
76179       {
76180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76181       };
76182     }
76183   }
76184
76185   jresult = result;
76186   return jresult;
76187 }
76188
76189
76190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76191   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76192   Dali::Vector2 *arg2 = 0 ;
76193
76194   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76195   arg2 = (Dali::Vector2 *)jarg2;
76196   if (!arg2) {
76197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76198     return ;
76199   }
76200   {
76201     try {
76202       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76203     } catch (std::out_of_range& e) {
76204       {
76205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76206       };
76207     } catch (std::exception& e) {
76208       {
76209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76210       };
76211     } catch (Dali::DaliException e) {
76212       {
76213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76214       };
76215     } catch (...) {
76216       {
76217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76218       };
76219     }
76220   }
76221
76222 }
76223
76224
76225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76227   Dali::Vector2 *arg2 = 0 ;
76228   float arg3 ;
76229
76230   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76231   arg2 = (Dali::Vector2 *)jarg2;
76232   if (!arg2) {
76233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76234     return ;
76235   }
76236   arg3 = (float)jarg3;
76237   {
76238     try {
76239       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76240     } catch (std::out_of_range& e) {
76241       {
76242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76243       };
76244     } catch (std::exception& e) {
76245       {
76246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76247       };
76248     } catch (Dali::DaliException e) {
76249       {
76250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76251       };
76252     } catch (...) {
76253       {
76254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76255       };
76256     }
76257   }
76258
76259 }
76260
76261
76262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76263   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76264   Dali::Vector2 *arg2 = 0 ;
76265   float arg3 ;
76266   Dali::AlphaFunction arg4 ;
76267   Dali::AlphaFunction *argp4 ;
76268
76269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76270   arg2 = (Dali::Vector2 *)jarg2;
76271   if (!arg2) {
76272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76273     return ;
76274   }
76275   arg3 = (float)jarg3;
76276   argp4 = (Dali::AlphaFunction *)jarg4;
76277   if (!argp4) {
76278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76279     return ;
76280   }
76281   arg4 = *argp4;
76282   {
76283     try {
76284       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76285     } catch (std::out_of_range& e) {
76286       {
76287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76288       };
76289     } catch (std::exception& e) {
76290       {
76291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76292       };
76293     } catch (Dali::DaliException e) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76296       };
76297     } catch (...) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76300       };
76301     }
76302   }
76303
76304 }
76305
76306
76307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76308   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76309   Dali::Vector2 *arg2 = 0 ;
76310   float arg3 ;
76311   Dali::Toolkit::DirectionBias arg4 ;
76312   Dali::Toolkit::DirectionBias arg5 ;
76313
76314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76315   arg2 = (Dali::Vector2 *)jarg2;
76316   if (!arg2) {
76317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76318     return ;
76319   }
76320   arg3 = (float)jarg3;
76321   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76322   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76323   {
76324     try {
76325       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76326     } catch (std::out_of_range& e) {
76327       {
76328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76329       };
76330     } catch (std::exception& e) {
76331       {
76332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76333       };
76334     } catch (Dali::DaliException e) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76337       };
76338     } catch (...) {
76339       {
76340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76341       };
76342     }
76343   }
76344
76345 }
76346
76347
76348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76350   Dali::Vector2 *arg2 = 0 ;
76351   float arg3 ;
76352   Dali::AlphaFunction arg4 ;
76353   Dali::Toolkit::DirectionBias arg5 ;
76354   Dali::Toolkit::DirectionBias arg6 ;
76355   Dali::AlphaFunction *argp4 ;
76356
76357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76358   arg2 = (Dali::Vector2 *)jarg2;
76359   if (!arg2) {
76360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76361     return ;
76362   }
76363   arg3 = (float)jarg3;
76364   argp4 = (Dali::AlphaFunction *)jarg4;
76365   if (!argp4) {
76366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76367     return ;
76368   }
76369   arg4 = *argp4;
76370   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76371   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76372   {
76373     try {
76374       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76375     } catch (std::out_of_range& e) {
76376       {
76377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76378       };
76379     } catch (std::exception& e) {
76380       {
76381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76382       };
76383     } catch (Dali::DaliException e) {
76384       {
76385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76386       };
76387     } catch (...) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76390       };
76391     }
76392   }
76393
76394 }
76395
76396
76397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76399   unsigned int arg2 ;
76400
76401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76402   arg2 = (unsigned int)jarg2;
76403   {
76404     try {
76405       (arg1)->ScrollTo(arg2);
76406     } catch (std::out_of_range& e) {
76407       {
76408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76409       };
76410     } catch (std::exception& e) {
76411       {
76412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76413       };
76414     } catch (Dali::DaliException e) {
76415       {
76416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76417       };
76418     } catch (...) {
76419       {
76420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76421       };
76422     }
76423   }
76424
76425 }
76426
76427
76428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76430   unsigned int arg2 ;
76431   float arg3 ;
76432
76433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76434   arg2 = (unsigned int)jarg2;
76435   arg3 = (float)jarg3;
76436   {
76437     try {
76438       (arg1)->ScrollTo(arg2,arg3);
76439     } catch (std::out_of_range& e) {
76440       {
76441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76442       };
76443     } catch (std::exception& e) {
76444       {
76445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76446       };
76447     } catch (Dali::DaliException e) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76450       };
76451     } catch (...) {
76452       {
76453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76454       };
76455     }
76456   }
76457
76458 }
76459
76460
76461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76463   unsigned int arg2 ;
76464   float arg3 ;
76465   Dali::Toolkit::DirectionBias arg4 ;
76466
76467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76468   arg2 = (unsigned int)jarg2;
76469   arg3 = (float)jarg3;
76470   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76471   {
76472     try {
76473       (arg1)->ScrollTo(arg2,arg3,arg4);
76474     } catch (std::out_of_range& e) {
76475       {
76476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76477       };
76478     } catch (std::exception& e) {
76479       {
76480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76481       };
76482     } catch (Dali::DaliException e) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76485       };
76486     } catch (...) {
76487       {
76488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76489       };
76490     }
76491   }
76492
76493 }
76494
76495
76496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76497   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76498   Dali::Actor *arg2 = 0 ;
76499
76500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76501   arg2 = (Dali::Actor *)jarg2;
76502   if (!arg2) {
76503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76504     return ;
76505   }
76506   {
76507     try {
76508       (arg1)->ScrollTo(*arg2);
76509     } catch (std::out_of_range& e) {
76510       {
76511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76512       };
76513     } catch (std::exception& e) {
76514       {
76515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (Dali::DaliException e) {
76518       {
76519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76524       };
76525     }
76526   }
76527
76528 }
76529
76530
76531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76532   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76533   Dali::Actor *arg2 = 0 ;
76534   float arg3 ;
76535
76536   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76537   arg2 = (Dali::Actor *)jarg2;
76538   if (!arg2) {
76539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76540     return ;
76541   }
76542   arg3 = (float)jarg3;
76543   {
76544     try {
76545       (arg1)->ScrollTo(*arg2,arg3);
76546     } catch (std::out_of_range& e) {
76547       {
76548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76549       };
76550     } catch (std::exception& e) {
76551       {
76552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76553       };
76554     } catch (Dali::DaliException e) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76557       };
76558     } catch (...) {
76559       {
76560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76561       };
76562     }
76563   }
76564
76565 }
76566
76567
76568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76569   unsigned int jresult ;
76570   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76571   bool result;
76572
76573   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76574   {
76575     try {
76576       result = (bool)(arg1)->ScrollToSnapPoint();
76577     } catch (std::out_of_range& e) {
76578       {
76579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (std::exception& e) {
76582       {
76583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76584       };
76585     } catch (Dali::DaliException e) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76588       };
76589     } catch (...) {
76590       {
76591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76592       };
76593     }
76594   }
76595
76596   jresult = result;
76597   return jresult;
76598 }
76599
76600
76601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76602   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76603   Dali::Constraint arg2 ;
76604   Dali::Constraint *argp2 ;
76605
76606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76607   argp2 = (Dali::Constraint *)jarg2;
76608   if (!argp2) {
76609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76610     return ;
76611   }
76612   arg2 = *argp2;
76613   {
76614     try {
76615       (arg1)->ApplyConstraintToChildren(arg2);
76616     } catch (std::out_of_range& e) {
76617       {
76618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76619       };
76620     } catch (std::exception& e) {
76621       {
76622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76623       };
76624     } catch (Dali::DaliException e) {
76625       {
76626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76627       };
76628     } catch (...) {
76629       {
76630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76631       };
76632     }
76633   }
76634
76635 }
76636
76637
76638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76640
76641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76642   {
76643     try {
76644       (arg1)->RemoveConstraintsFromChildren();
76645     } catch (std::out_of_range& e) {
76646       {
76647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76648       };
76649     } catch (std::exception& e) {
76650       {
76651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76652       };
76653     } catch (Dali::DaliException e) {
76654       {
76655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76656       };
76657     } catch (...) {
76658       {
76659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76660       };
76661     }
76662   }
76663
76664 }
76665
76666
76667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76669   Dali::Toolkit::ScrollViewEffect arg2 ;
76670   Dali::Toolkit::ScrollViewEffect *argp2 ;
76671
76672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76673   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76674   if (!argp2) {
76675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76676     return ;
76677   }
76678   arg2 = *argp2;
76679   {
76680     try {
76681       (arg1)->ApplyEffect(arg2);
76682     } catch (std::out_of_range& e) {
76683       {
76684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76685       };
76686     } catch (std::exception& e) {
76687       {
76688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76689       };
76690     } catch (Dali::DaliException e) {
76691       {
76692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76693       };
76694     } catch (...) {
76695       {
76696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76697       };
76698     }
76699   }
76700
76701 }
76702
76703
76704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76706   Dali::Toolkit::ScrollViewEffect arg2 ;
76707   Dali::Toolkit::ScrollViewEffect *argp2 ;
76708
76709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76710   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76711   if (!argp2) {
76712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76713     return ;
76714   }
76715   arg2 = *argp2;
76716   {
76717     try {
76718       (arg1)->RemoveEffect(arg2);
76719     } catch (std::out_of_range& e) {
76720       {
76721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76722       };
76723     } catch (std::exception& e) {
76724       {
76725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76726       };
76727     } catch (Dali::DaliException e) {
76728       {
76729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76730       };
76731     } catch (...) {
76732       {
76733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76734       };
76735     }
76736   }
76737
76738 }
76739
76740
76741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76742   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76743
76744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76745   {
76746     try {
76747       (arg1)->RemoveAllEffects();
76748     } catch (std::out_of_range& e) {
76749       {
76750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76751       };
76752     } catch (std::exception& e) {
76753       {
76754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76755       };
76756     } catch (Dali::DaliException e) {
76757       {
76758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76759       };
76760     } catch (...) {
76761       {
76762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76763       };
76764     }
76765   }
76766
76767 }
76768
76769
76770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76772   Dali::Actor arg2 ;
76773   Dali::Actor *argp2 ;
76774
76775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76776   argp2 = (Dali::Actor *)jarg2;
76777   if (!argp2) {
76778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76779     return ;
76780   }
76781   arg2 = *argp2;
76782   {
76783     try {
76784       (arg1)->BindActor(arg2);
76785     } catch (std::out_of_range& e) {
76786       {
76787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76788       };
76789     } catch (std::exception& e) {
76790       {
76791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76792       };
76793     } catch (Dali::DaliException e) {
76794       {
76795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76796       };
76797     } catch (...) {
76798       {
76799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76800       };
76801     }
76802   }
76803
76804 }
76805
76806
76807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76808   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76809   Dali::Actor arg2 ;
76810   Dali::Actor *argp2 ;
76811
76812   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76813   argp2 = (Dali::Actor *)jarg2;
76814   if (!argp2) {
76815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76816     return ;
76817   }
76818   arg2 = *argp2;
76819   {
76820     try {
76821       (arg1)->UnbindActor(arg2);
76822     } catch (std::out_of_range& e) {
76823       {
76824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76825       };
76826     } catch (std::exception& e) {
76827       {
76828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76829       };
76830     } catch (Dali::DaliException e) {
76831       {
76832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76833       };
76834     } catch (...) {
76835       {
76836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76837       };
76838     }
76839   }
76840
76841 }
76842
76843
76844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76846   Dali::Radian arg2 ;
76847   Dali::Radian arg3 ;
76848   Dali::Radian *argp2 ;
76849   Dali::Radian *argp3 ;
76850
76851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76852   argp2 = (Dali::Radian *)jarg2;
76853   if (!argp2) {
76854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76855     return ;
76856   }
76857   arg2 = *argp2;
76858   argp3 = (Dali::Radian *)jarg3;
76859   if (!argp3) {
76860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76861     return ;
76862   }
76863   arg3 = *argp3;
76864   {
76865     try {
76866       (arg1)->SetScrollingDirection(arg2,arg3);
76867     } catch (std::out_of_range& e) {
76868       {
76869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76870       };
76871     } catch (std::exception& e) {
76872       {
76873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76874       };
76875     } catch (Dali::DaliException e) {
76876       {
76877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76878       };
76879     } catch (...) {
76880       {
76881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76882       };
76883     }
76884   }
76885
76886 }
76887
76888
76889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76891   Dali::Radian arg2 ;
76892   Dali::Radian *argp2 ;
76893
76894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76895   argp2 = (Dali::Radian *)jarg2;
76896   if (!argp2) {
76897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76898     return ;
76899   }
76900   arg2 = *argp2;
76901   {
76902     try {
76903       (arg1)->SetScrollingDirection(arg2);
76904     } catch (std::out_of_range& e) {
76905       {
76906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76907       };
76908     } catch (std::exception& e) {
76909       {
76910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76911       };
76912     } catch (Dali::DaliException e) {
76913       {
76914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76915       };
76916     } catch (...) {
76917       {
76918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76919       };
76920     }
76921   }
76922
76923 }
76924
76925
76926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76927   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76928   Dali::Radian arg2 ;
76929   Dali::Radian *argp2 ;
76930
76931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76932   argp2 = (Dali::Radian *)jarg2;
76933   if (!argp2) {
76934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76935     return ;
76936   }
76937   arg2 = *argp2;
76938   {
76939     try {
76940       (arg1)->RemoveScrollingDirection(arg2);
76941     } catch (std::out_of_range& e) {
76942       {
76943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76944       };
76945     } catch (std::exception& e) {
76946       {
76947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76948       };
76949     } catch (Dali::DaliException e) {
76950       {
76951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76952       };
76953     } catch (...) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76956       };
76957     }
76958   }
76959
76960 }
76961
76962
76963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76964   void * jresult ;
76965   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76966   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76967
76968   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76969   {
76970     try {
76971       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76972     } catch (std::out_of_range& e) {
76973       {
76974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76975       };
76976     } catch (std::exception& e) {
76977       {
76978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76979       };
76980     } catch (Dali::DaliException e) {
76981       {
76982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76983       };
76984     } catch (...) {
76985       {
76986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76987       };
76988     }
76989   }
76990
76991   jresult = (void *)result;
76992   return jresult;
76993 }
76994
76995
76996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76997   int jresult ;
76998   int result;
76999
77000   result = (int)Dali::Toolkit::TableView::Property::ROWS;
77001   jresult = (int)result;
77002   return jresult;
77003 }
77004
77005
77006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
77007   int jresult ;
77008   int result;
77009
77010   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
77011   jresult = (int)result;
77012   return jresult;
77013 }
77014
77015
77016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
77017   int jresult ;
77018   int result;
77019
77020   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
77021   jresult = (int)result;
77022   return jresult;
77023 }
77024
77025
77026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
77027   int jresult ;
77028   int result;
77029
77030   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
77031   jresult = (int)result;
77032   return jresult;
77033 }
77034
77035
77036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
77037   int jresult ;
77038   int result;
77039
77040   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
77041   jresult = (int)result;
77042   return jresult;
77043 }
77044
77045
77046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
77047   void * jresult ;
77048   Dali::Toolkit::TableView::Property *result = 0 ;
77049
77050   {
77051     try {
77052       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77068       };
77069     }
77070   }
77071
77072   jresult = (void *)result;
77073   return jresult;
77074 }
77075
77076
77077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
77078   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
77079
77080   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
77081   {
77082     try {
77083       delete arg1;
77084     } catch (std::out_of_range& e) {
77085       {
77086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77087       };
77088     } catch (std::exception& e) {
77089       {
77090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77091       };
77092     } catch (Dali::DaliException e) {
77093       {
77094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77095       };
77096     } catch (...) {
77097       {
77098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77099       };
77100     }
77101   }
77102
77103 }
77104
77105
77106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
77107   int jresult ;
77108   int result;
77109
77110   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
77111   jresult = (int)result;
77112   return jresult;
77113 }
77114
77115
77116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
77117   int jresult ;
77118   int result;
77119
77120   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
77121   jresult = (int)result;
77122   return jresult;
77123 }
77124
77125
77126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
77127   int jresult ;
77128   int result;
77129
77130   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
77131   jresult = (int)result;
77132   return jresult;
77133 }
77134
77135
77136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
77137   int jresult ;
77138   int result;
77139
77140   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
77141   jresult = (int)result;
77142   return jresult;
77143 }
77144
77145
77146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
77147   int jresult ;
77148   int result;
77149
77150   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
77151   jresult = (int)result;
77152   return jresult;
77153 }
77154
77155
77156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
77157   void * jresult ;
77158   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
77159
77160   {
77161     try {
77162       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
77163     } catch (std::out_of_range& e) {
77164       {
77165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77166       };
77167     } catch (std::exception& e) {
77168       {
77169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77170       };
77171     } catch (Dali::DaliException e) {
77172       {
77173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77174       };
77175     } catch (...) {
77176       {
77177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77178       };
77179     }
77180   }
77181
77182   jresult = (void *)result;
77183   return jresult;
77184 }
77185
77186
77187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77188   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77189
77190   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77191   {
77192     try {
77193       delete arg1;
77194     } catch (std::out_of_range& e) {
77195       {
77196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77197       };
77198     } catch (std::exception& e) {
77199       {
77200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77201       };
77202     } catch (Dali::DaliException e) {
77203       {
77204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77205       };
77206     } catch (...) {
77207       {
77208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77209       };
77210     }
77211   }
77212
77213 }
77214
77215
77216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77217   void * jresult ;
77218   unsigned int arg1 ;
77219   unsigned int arg2 ;
77220   unsigned int arg3 ;
77221   unsigned int arg4 ;
77222   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77223
77224   arg1 = (unsigned int)jarg1;
77225   arg2 = (unsigned int)jarg2;
77226   arg3 = (unsigned int)jarg3;
77227   arg4 = (unsigned int)jarg4;
77228   {
77229     try {
77230       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77231     } catch (std::out_of_range& e) {
77232       {
77233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77234       };
77235     } catch (std::exception& e) {
77236       {
77237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (Dali::DaliException e) {
77240       {
77241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77242       };
77243     } catch (...) {
77244       {
77245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77246       };
77247     }
77248   }
77249
77250   jresult = (void *)result;
77251   return jresult;
77252 }
77253
77254
77255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77256   void * jresult ;
77257   unsigned int arg1 ;
77258   unsigned int arg2 ;
77259   unsigned int arg3 ;
77260   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77261
77262   arg1 = (unsigned int)jarg1;
77263   arg2 = (unsigned int)jarg2;
77264   arg3 = (unsigned int)jarg3;
77265   {
77266     try {
77267       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77268     } catch (std::out_of_range& e) {
77269       {
77270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77271       };
77272     } catch (std::exception& e) {
77273       {
77274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77275       };
77276     } catch (Dali::DaliException e) {
77277       {
77278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77279       };
77280     } catch (...) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77283       };
77284     }
77285   }
77286
77287   jresult = (void *)result;
77288   return jresult;
77289 }
77290
77291
77292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77293   void * jresult ;
77294   unsigned int arg1 ;
77295   unsigned int arg2 ;
77296   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77297
77298   arg1 = (unsigned int)jarg1;
77299   arg2 = (unsigned int)jarg2;
77300   {
77301     try {
77302       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77303     } catch (std::out_of_range& e) {
77304       {
77305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77306       };
77307     } catch (std::exception& e) {
77308       {
77309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77310       };
77311     } catch (Dali::DaliException e) {
77312       {
77313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77314       };
77315     } catch (...) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77318       };
77319     }
77320   }
77321
77322   jresult = (void *)result;
77323   return jresult;
77324 }
77325
77326
77327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77328   void * jresult ;
77329   unsigned int arg1 ;
77330   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77331
77332   arg1 = (unsigned int)jarg1;
77333   {
77334     try {
77335       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77336     } catch (std::out_of_range& e) {
77337       {
77338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77339       };
77340     } catch (std::exception& e) {
77341       {
77342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77343       };
77344     } catch (Dali::DaliException e) {
77345       {
77346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77347       };
77348     } catch (...) {
77349       {
77350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77351       };
77352     }
77353   }
77354
77355   jresult = (void *)result;
77356   return jresult;
77357 }
77358
77359
77360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77361   void * jresult ;
77362   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77363
77364   {
77365     try {
77366       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77367     } catch (std::out_of_range& e) {
77368       {
77369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77370       };
77371     } catch (std::exception& e) {
77372       {
77373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77374       };
77375     } catch (Dali::DaliException e) {
77376       {
77377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77378       };
77379     } catch (...) {
77380       {
77381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77382       };
77383     }
77384   }
77385
77386   jresult = (void *)result;
77387   return jresult;
77388 }
77389
77390
77391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77392   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77393   unsigned int arg2 ;
77394
77395   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77396   arg2 = (unsigned int)jarg2;
77397   if (arg1) (arg1)->rowIndex = arg2;
77398 }
77399
77400
77401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77402   unsigned int jresult ;
77403   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77404   unsigned int result;
77405
77406   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77407   result = (unsigned int) ((arg1)->rowIndex);
77408   jresult = result;
77409   return jresult;
77410 }
77411
77412
77413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77414   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77415   unsigned int arg2 ;
77416
77417   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77418   arg2 = (unsigned int)jarg2;
77419   if (arg1) (arg1)->columnIndex = arg2;
77420 }
77421
77422
77423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77424   unsigned int jresult ;
77425   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77426   unsigned int result;
77427
77428   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77429   result = (unsigned int) ((arg1)->columnIndex);
77430   jresult = result;
77431   return jresult;
77432 }
77433
77434
77435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77436   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77437   unsigned int arg2 ;
77438
77439   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77440   arg2 = (unsigned int)jarg2;
77441   if (arg1) (arg1)->rowSpan = arg2;
77442 }
77443
77444
77445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77446   unsigned int jresult ;
77447   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77448   unsigned int result;
77449
77450   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77451   result = (unsigned int) ((arg1)->rowSpan);
77452   jresult = result;
77453   return jresult;
77454 }
77455
77456
77457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77458   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77459   unsigned int arg2 ;
77460
77461   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77462   arg2 = (unsigned int)jarg2;
77463   if (arg1) (arg1)->columnSpan = arg2;
77464 }
77465
77466
77467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77468   unsigned int jresult ;
77469   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77470   unsigned int result;
77471
77472   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77473   result = (unsigned int) ((arg1)->columnSpan);
77474   jresult = result;
77475   return jresult;
77476 }
77477
77478
77479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77480   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77481
77482   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77483   {
77484     try {
77485       delete arg1;
77486     } catch (std::out_of_range& e) {
77487       {
77488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77489       };
77490     } catch (std::exception& e) {
77491       {
77492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77493       };
77494     } catch (Dali::DaliException e) {
77495       {
77496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77497       };
77498     } catch (...) {
77499       {
77500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77501       };
77502     }
77503   }
77504
77505 }
77506
77507
77508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77509   void * jresult ;
77510   Dali::Toolkit::TableView *result = 0 ;
77511
77512   {
77513     try {
77514       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77515     } catch (std::out_of_range& e) {
77516       {
77517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77518       };
77519     } catch (std::exception& e) {
77520       {
77521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (Dali::DaliException e) {
77524       {
77525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77526       };
77527     } catch (...) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77530       };
77531     }
77532   }
77533
77534   jresult = (void *)result;
77535   return jresult;
77536 }
77537
77538
77539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77540   void * jresult ;
77541   Dali::Toolkit::TableView *arg1 = 0 ;
77542   Dali::Toolkit::TableView *result = 0 ;
77543
77544   arg1 = (Dali::Toolkit::TableView *)jarg1;
77545   if (!arg1) {
77546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77547     return 0;
77548   }
77549   {
77550     try {
77551       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77552     } catch (std::out_of_range& e) {
77553       {
77554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77555       };
77556     } catch (std::exception& e) {
77557       {
77558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77559       };
77560     } catch (Dali::DaliException e) {
77561       {
77562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77563       };
77564     } catch (...) {
77565       {
77566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77567       };
77568     }
77569   }
77570
77571   jresult = (void *)result;
77572   return jresult;
77573 }
77574
77575
77576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77577   void * jresult ;
77578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77579   Dali::Toolkit::TableView *arg2 = 0 ;
77580   Dali::Toolkit::TableView *result = 0 ;
77581
77582   arg1 = (Dali::Toolkit::TableView *)jarg1;
77583   arg2 = (Dali::Toolkit::TableView *)jarg2;
77584   if (!arg2) {
77585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77586     return 0;
77587   }
77588   {
77589     try {
77590       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77591     } catch (std::out_of_range& e) {
77592       {
77593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77594       };
77595     } catch (std::exception& e) {
77596       {
77597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77598       };
77599     } catch (Dali::DaliException e) {
77600       {
77601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77602       };
77603     } catch (...) {
77604       {
77605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77606       };
77607     }
77608   }
77609
77610   jresult = (void *)result;
77611   return jresult;
77612 }
77613
77614
77615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77616   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77617
77618   arg1 = (Dali::Toolkit::TableView *)jarg1;
77619   {
77620     try {
77621       delete arg1;
77622     } catch (std::out_of_range& e) {
77623       {
77624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77625       };
77626     } catch (std::exception& e) {
77627       {
77628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77629       };
77630     } catch (Dali::DaliException e) {
77631       {
77632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77633       };
77634     } catch (...) {
77635       {
77636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77637       };
77638     }
77639   }
77640
77641 }
77642
77643
77644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77645   void * jresult ;
77646   unsigned int arg1 ;
77647   unsigned int arg2 ;
77648   Dali::Toolkit::TableView result;
77649
77650   arg1 = (unsigned int)jarg1;
77651   arg2 = (unsigned int)jarg2;
77652   {
77653     try {
77654       result = Dali::Toolkit::TableView::New(arg1,arg2);
77655     } catch (std::out_of_range& e) {
77656       {
77657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77658       };
77659     } catch (std::exception& e) {
77660       {
77661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77662       };
77663     } catch (Dali::DaliException e) {
77664       {
77665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77666       };
77667     } catch (...) {
77668       {
77669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77670       };
77671     }
77672   }
77673
77674   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77675   return jresult;
77676 }
77677
77678
77679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77680   void * jresult ;
77681   Dali::BaseHandle arg1 ;
77682   Dali::BaseHandle *argp1 ;
77683   Dali::Toolkit::TableView result;
77684
77685   argp1 = (Dali::BaseHandle *)jarg1;
77686   if (!argp1) {
77687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77688     return 0;
77689   }
77690   arg1 = *argp1;
77691   {
77692     try {
77693       result = Dali::Toolkit::TableView::DownCast(arg1);
77694     } catch (std::out_of_range& e) {
77695       {
77696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77697       };
77698     } catch (std::exception& e) {
77699       {
77700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77701       };
77702     } catch (Dali::DaliException e) {
77703       {
77704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77705       };
77706     } catch (...) {
77707       {
77708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77709       };
77710     }
77711   }
77712
77713   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77714   return jresult;
77715 }
77716
77717
77718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77719   unsigned int jresult ;
77720   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77721   Dali::Actor arg2 ;
77722   Dali::Toolkit::TableView::CellPosition arg3 ;
77723   Dali::Actor *argp2 ;
77724   Dali::Toolkit::TableView::CellPosition *argp3 ;
77725   bool result;
77726
77727   arg1 = (Dali::Toolkit::TableView *)jarg1;
77728   argp2 = (Dali::Actor *)jarg2;
77729   if (!argp2) {
77730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77731     return 0;
77732   }
77733   arg2 = *argp2;
77734   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77735   if (!argp3) {
77736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77737     return 0;
77738   }
77739   arg3 = *argp3;
77740   {
77741     try {
77742       result = (bool)(arg1)->AddChild(arg2,arg3);
77743     } catch (std::out_of_range& e) {
77744       {
77745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77746       };
77747     } catch (std::exception& e) {
77748       {
77749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77750       };
77751     } catch (Dali::DaliException e) {
77752       {
77753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77754       };
77755     } catch (...) {
77756       {
77757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77758       };
77759     }
77760   }
77761
77762   jresult = result;
77763   return jresult;
77764 }
77765
77766
77767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77768   void * jresult ;
77769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77770   Dali::Toolkit::TableView::CellPosition arg2 ;
77771   Dali::Toolkit::TableView::CellPosition *argp2 ;
77772   Dali::Actor result;
77773
77774   arg1 = (Dali::Toolkit::TableView *)jarg1;
77775   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77776   if (!argp2) {
77777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77778     return 0;
77779   }
77780   arg2 = *argp2;
77781   {
77782     try {
77783       result = (arg1)->GetChildAt(arg2);
77784     } catch (std::out_of_range& e) {
77785       {
77786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77787       };
77788     } catch (std::exception& e) {
77789       {
77790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (Dali::DaliException e) {
77793       {
77794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77795       };
77796     } catch (...) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77799       };
77800     }
77801   }
77802
77803   jresult = new Dali::Actor((const Dali::Actor &)result);
77804   return jresult;
77805 }
77806
77807
77808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77809   void * jresult ;
77810   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77811   Dali::Toolkit::TableView::CellPosition arg2 ;
77812   Dali::Toolkit::TableView::CellPosition *argp2 ;
77813   Dali::Actor result;
77814
77815   arg1 = (Dali::Toolkit::TableView *)jarg1;
77816   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77817   if (!argp2) {
77818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77819     return 0;
77820   }
77821   arg2 = *argp2;
77822   {
77823     try {
77824       result = (arg1)->RemoveChildAt(arg2);
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77840       };
77841     }
77842   }
77843
77844   jresult = new Dali::Actor((const Dali::Actor &)result);
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77850   unsigned int jresult ;
77851   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77852   Dali::Actor arg2 ;
77853   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77854   Dali::Actor *argp2 ;
77855   bool result;
77856
77857   arg1 = (Dali::Toolkit::TableView *)jarg1;
77858   argp2 = (Dali::Actor *)jarg2;
77859   if (!argp2) {
77860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77861     return 0;
77862   }
77863   arg2 = *argp2;
77864   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77865   if (!arg3) {
77866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77867     return 0;
77868   }
77869   {
77870     try {
77871       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77872     } catch (std::out_of_range& e) {
77873       {
77874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77875       };
77876     } catch (std::exception& e) {
77877       {
77878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77879       };
77880     } catch (Dali::DaliException e) {
77881       {
77882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77883       };
77884     } catch (...) {
77885       {
77886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77887       };
77888     }
77889   }
77890
77891   jresult = result;
77892   return jresult;
77893 }
77894
77895
77896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77897   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77898   unsigned int arg2 ;
77899
77900   arg1 = (Dali::Toolkit::TableView *)jarg1;
77901   arg2 = (unsigned int)jarg2;
77902   {
77903     try {
77904       (arg1)->InsertRow(arg2);
77905     } catch (std::out_of_range& e) {
77906       {
77907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77908       };
77909     } catch (std::exception& e) {
77910       {
77911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77912       };
77913     } catch (Dali::DaliException e) {
77914       {
77915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77916       };
77917     } catch (...) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77920       };
77921     }
77922   }
77923
77924 }
77925
77926
77927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77928   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77929   unsigned int arg2 ;
77930
77931   arg1 = (Dali::Toolkit::TableView *)jarg1;
77932   arg2 = (unsigned int)jarg2;
77933   {
77934     try {
77935       (arg1)->DeleteRow(arg2);
77936     } catch (std::out_of_range& e) {
77937       {
77938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77939       };
77940     } catch (std::exception& e) {
77941       {
77942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77943       };
77944     } catch (Dali::DaliException e) {
77945       {
77946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77947       };
77948     } catch (...) {
77949       {
77950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77951       };
77952     }
77953   }
77954
77955 }
77956
77957
77958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77959   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77960   unsigned int arg2 ;
77961   std::vector< Dali::Actor > *arg3 = 0 ;
77962
77963   arg1 = (Dali::Toolkit::TableView *)jarg1;
77964   arg2 = (unsigned int)jarg2;
77965   arg3 = (std::vector< Dali::Actor > *)jarg3;
77966   if (!arg3) {
77967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77968     return ;
77969   }
77970   {
77971     try {
77972       (arg1)->DeleteRow(arg2,*arg3);
77973     } catch (std::out_of_range& e) {
77974       {
77975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77976       };
77977     } catch (std::exception& e) {
77978       {
77979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77980       };
77981     } catch (Dali::DaliException e) {
77982       {
77983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77984       };
77985     } catch (...) {
77986       {
77987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77988       };
77989     }
77990   }
77991
77992 }
77993
77994
77995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77996   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77997   unsigned int arg2 ;
77998
77999   arg1 = (Dali::Toolkit::TableView *)jarg1;
78000   arg2 = (unsigned int)jarg2;
78001   {
78002     try {
78003       (arg1)->InsertColumn(arg2);
78004     } catch (std::out_of_range& e) {
78005       {
78006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78007       };
78008     } catch (std::exception& e) {
78009       {
78010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78011       };
78012     } catch (Dali::DaliException e) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78015       };
78016     } catch (...) {
78017       {
78018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78019       };
78020     }
78021   }
78022
78023 }
78024
78025
78026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
78027   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78028   unsigned int arg2 ;
78029
78030   arg1 = (Dali::Toolkit::TableView *)jarg1;
78031   arg2 = (unsigned int)jarg2;
78032   {
78033     try {
78034       (arg1)->DeleteColumn(arg2);
78035     } catch (std::out_of_range& e) {
78036       {
78037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78038       };
78039     } catch (std::exception& e) {
78040       {
78041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78042       };
78043     } catch (Dali::DaliException e) {
78044       {
78045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78046       };
78047     } catch (...) {
78048       {
78049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78050       };
78051     }
78052   }
78053
78054 }
78055
78056
78057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78058   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78059   unsigned int arg2 ;
78060   std::vector< Dali::Actor > *arg3 = 0 ;
78061
78062   arg1 = (Dali::Toolkit::TableView *)jarg1;
78063   arg2 = (unsigned int)jarg2;
78064   arg3 = (std::vector< Dali::Actor > *)jarg3;
78065   if (!arg3) {
78066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78067     return ;
78068   }
78069   {
78070     try {
78071       (arg1)->DeleteColumn(arg2,*arg3);
78072     } catch (std::out_of_range& e) {
78073       {
78074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78075       };
78076     } catch (std::exception& e) {
78077       {
78078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78079       };
78080     } catch (Dali::DaliException e) {
78081       {
78082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78083       };
78084     } catch (...) {
78085       {
78086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78087       };
78088     }
78089   }
78090
78091 }
78092
78093
78094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
78095   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78096   unsigned int arg2 ;
78097   unsigned int arg3 ;
78098
78099   arg1 = (Dali::Toolkit::TableView *)jarg1;
78100   arg2 = (unsigned int)jarg2;
78101   arg3 = (unsigned int)jarg3;
78102   {
78103     try {
78104       (arg1)->Resize(arg2,arg3);
78105     } catch (std::out_of_range& e) {
78106       {
78107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78108       };
78109     } catch (std::exception& e) {
78110       {
78111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78112       };
78113     } catch (Dali::DaliException e) {
78114       {
78115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78116       };
78117     } catch (...) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78120       };
78121     }
78122   }
78123
78124 }
78125
78126
78127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
78128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78129   unsigned int arg2 ;
78130   unsigned int arg3 ;
78131   std::vector< Dali::Actor > *arg4 = 0 ;
78132
78133   arg1 = (Dali::Toolkit::TableView *)jarg1;
78134   arg2 = (unsigned int)jarg2;
78135   arg3 = (unsigned int)jarg3;
78136   arg4 = (std::vector< Dali::Actor > *)jarg4;
78137   if (!arg4) {
78138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78139     return ;
78140   }
78141   {
78142     try {
78143       (arg1)->Resize(arg2,arg3,*arg4);
78144     } catch (std::out_of_range& e) {
78145       {
78146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78147       };
78148     } catch (std::exception& e) {
78149       {
78150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78151       };
78152     } catch (Dali::DaliException e) {
78153       {
78154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78159       };
78160     }
78161   }
78162
78163 }
78164
78165
78166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
78167   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78168   Dali::Size arg2 ;
78169   Dali::Size *argp2 ;
78170
78171   arg1 = (Dali::Toolkit::TableView *)jarg1;
78172   argp2 = (Dali::Size *)jarg2;
78173   if (!argp2) {
78174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78175     return ;
78176   }
78177   arg2 = *argp2;
78178   {
78179     try {
78180       (arg1)->SetCellPadding(arg2);
78181     } catch (std::out_of_range& e) {
78182       {
78183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78184       };
78185     } catch (std::exception& e) {
78186       {
78187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78188       };
78189     } catch (Dali::DaliException e) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78192       };
78193     } catch (...) {
78194       {
78195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78196       };
78197     }
78198   }
78199
78200 }
78201
78202
78203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78204   void * jresult ;
78205   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78206   Dali::Size result;
78207
78208   arg1 = (Dali::Toolkit::TableView *)jarg1;
78209   {
78210     try {
78211       result = (arg1)->GetCellPadding();
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78219       };
78220     } catch (Dali::DaliException e) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78223       };
78224     } catch (...) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78227       };
78228     }
78229   }
78230
78231   jresult = new Dali::Size((const Dali::Size &)result);
78232   return jresult;
78233 }
78234
78235
78236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78237   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78238   unsigned int arg2 ;
78239
78240   arg1 = (Dali::Toolkit::TableView *)jarg1;
78241   arg2 = (unsigned int)jarg2;
78242   {
78243     try {
78244       (arg1)->SetFitHeight(arg2);
78245     } catch (std::out_of_range& e) {
78246       {
78247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78248       };
78249     } catch (std::exception& e) {
78250       {
78251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78252       };
78253     } catch (Dali::DaliException e) {
78254       {
78255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78256       };
78257     } catch (...) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78260       };
78261     }
78262   }
78263
78264 }
78265
78266
78267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78268   unsigned int jresult ;
78269   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78270   unsigned int arg2 ;
78271   bool result;
78272
78273   arg1 = (Dali::Toolkit::TableView *)jarg1;
78274   arg2 = (unsigned int)jarg2;
78275   {
78276     try {
78277       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78278     } catch (std::out_of_range& e) {
78279       {
78280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78281       };
78282     } catch (std::exception& e) {
78283       {
78284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78285       };
78286     } catch (Dali::DaliException e) {
78287       {
78288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78289       };
78290     } catch (...) {
78291       {
78292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78293       };
78294     }
78295   }
78296
78297   jresult = result;
78298   return jresult;
78299 }
78300
78301
78302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78303   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78304   unsigned int arg2 ;
78305
78306   arg1 = (Dali::Toolkit::TableView *)jarg1;
78307   arg2 = (unsigned int)jarg2;
78308   {
78309     try {
78310       (arg1)->SetFitWidth(arg2);
78311     } catch (std::out_of_range& e) {
78312       {
78313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78314       };
78315     } catch (std::exception& e) {
78316       {
78317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78318       };
78319     } catch (Dali::DaliException e) {
78320       {
78321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78322       };
78323     } catch (...) {
78324       {
78325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78326       };
78327     }
78328   }
78329
78330 }
78331
78332
78333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78334   unsigned int jresult ;
78335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78336   unsigned int arg2 ;
78337   bool result;
78338
78339   arg1 = (Dali::Toolkit::TableView *)jarg1;
78340   arg2 = (unsigned int)jarg2;
78341   {
78342     try {
78343       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78344     } catch (std::out_of_range& e) {
78345       {
78346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (std::exception& e) {
78349       {
78350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78351       };
78352     } catch (Dali::DaliException e) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78355       };
78356     } catch (...) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78359       };
78360     }
78361   }
78362
78363   jresult = result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78370   unsigned int arg2 ;
78371   float arg3 ;
78372
78373   arg1 = (Dali::Toolkit::TableView *)jarg1;
78374   arg2 = (unsigned int)jarg2;
78375   arg3 = (float)jarg3;
78376   {
78377     try {
78378       (arg1)->SetFixedHeight(arg2,arg3);
78379     } catch (std::out_of_range& e) {
78380       {
78381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78382       };
78383     } catch (std::exception& e) {
78384       {
78385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78386       };
78387     } catch (Dali::DaliException e) {
78388       {
78389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78390       };
78391     } catch (...) {
78392       {
78393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78394       };
78395     }
78396   }
78397
78398 }
78399
78400
78401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78402   float jresult ;
78403   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78404   unsigned int arg2 ;
78405   float result;
78406
78407   arg1 = (Dali::Toolkit::TableView *)jarg1;
78408   arg2 = (unsigned int)jarg2;
78409   {
78410     try {
78411       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78412     } catch (std::out_of_range& e) {
78413       {
78414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78415       };
78416     } catch (std::exception& e) {
78417       {
78418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78419       };
78420     } catch (Dali::DaliException e) {
78421       {
78422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78423       };
78424     } catch (...) {
78425       {
78426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78427       };
78428     }
78429   }
78430
78431   jresult = result;
78432   return jresult;
78433 }
78434
78435
78436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78437   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78438   unsigned int arg2 ;
78439   float arg3 ;
78440
78441   arg1 = (Dali::Toolkit::TableView *)jarg1;
78442   arg2 = (unsigned int)jarg2;
78443   arg3 = (float)jarg3;
78444   {
78445     try {
78446       (arg1)->SetRelativeHeight(arg2,arg3);
78447     } catch (std::out_of_range& e) {
78448       {
78449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78450       };
78451     } catch (std::exception& e) {
78452       {
78453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78454       };
78455     } catch (Dali::DaliException e) {
78456       {
78457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78458       };
78459     } catch (...) {
78460       {
78461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78462       };
78463     }
78464   }
78465
78466 }
78467
78468
78469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78470   float jresult ;
78471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78472   unsigned int arg2 ;
78473   float result;
78474
78475   arg1 = (Dali::Toolkit::TableView *)jarg1;
78476   arg2 = (unsigned int)jarg2;
78477   {
78478     try {
78479       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78480     } catch (std::out_of_range& e) {
78481       {
78482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78483       };
78484     } catch (std::exception& e) {
78485       {
78486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78487       };
78488     } catch (Dali::DaliException e) {
78489       {
78490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78491       };
78492     } catch (...) {
78493       {
78494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78495       };
78496     }
78497   }
78498
78499   jresult = result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78506   unsigned int arg2 ;
78507   float arg3 ;
78508
78509   arg1 = (Dali::Toolkit::TableView *)jarg1;
78510   arg2 = (unsigned int)jarg2;
78511   arg3 = (float)jarg3;
78512   {
78513     try {
78514       (arg1)->SetFixedWidth(arg2,arg3);
78515     } catch (std::out_of_range& e) {
78516       {
78517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78518       };
78519     } catch (std::exception& e) {
78520       {
78521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78522       };
78523     } catch (Dali::DaliException e) {
78524       {
78525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78526       };
78527     } catch (...) {
78528       {
78529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78530       };
78531     }
78532   }
78533
78534 }
78535
78536
78537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78538   float jresult ;
78539   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78540   unsigned int arg2 ;
78541   float result;
78542
78543   arg1 = (Dali::Toolkit::TableView *)jarg1;
78544   arg2 = (unsigned int)jarg2;
78545   {
78546     try {
78547       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78548     } catch (std::out_of_range& e) {
78549       {
78550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78551       };
78552     } catch (std::exception& e) {
78553       {
78554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78555       };
78556     } catch (Dali::DaliException e) {
78557       {
78558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78559       };
78560     } catch (...) {
78561       {
78562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78563       };
78564     }
78565   }
78566
78567   jresult = result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78573   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78574   unsigned int arg2 ;
78575   float arg3 ;
78576
78577   arg1 = (Dali::Toolkit::TableView *)jarg1;
78578   arg2 = (unsigned int)jarg2;
78579   arg3 = (float)jarg3;
78580   {
78581     try {
78582       (arg1)->SetRelativeWidth(arg2,arg3);
78583     } catch (std::out_of_range& e) {
78584       {
78585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78586       };
78587     } catch (std::exception& e) {
78588       {
78589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78590       };
78591     } catch (Dali::DaliException e) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78594       };
78595     } catch (...) {
78596       {
78597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78598       };
78599     }
78600   }
78601
78602 }
78603
78604
78605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78606   float jresult ;
78607   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78608   unsigned int arg2 ;
78609   float result;
78610
78611   arg1 = (Dali::Toolkit::TableView *)jarg1;
78612   arg2 = (unsigned int)jarg2;
78613   {
78614     try {
78615       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78623       };
78624     } catch (Dali::DaliException e) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78627       };
78628     } catch (...) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78631       };
78632     }
78633   }
78634
78635   jresult = result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78641   unsigned int jresult ;
78642   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78643   unsigned int result;
78644
78645   arg1 = (Dali::Toolkit::TableView *)jarg1;
78646   {
78647     try {
78648       result = (unsigned int)(arg1)->GetRows();
78649     } catch (std::out_of_range& e) {
78650       {
78651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78652       };
78653     } catch (std::exception& e) {
78654       {
78655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78656       };
78657     } catch (Dali::DaliException e) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78660       };
78661     } catch (...) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78664       };
78665     }
78666   }
78667
78668   jresult = result;
78669   return jresult;
78670 }
78671
78672
78673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78674   unsigned int jresult ;
78675   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78676   unsigned int result;
78677
78678   arg1 = (Dali::Toolkit::TableView *)jarg1;
78679   {
78680     try {
78681       result = (unsigned int)(arg1)->GetColumns();
78682     } catch (std::out_of_range& e) {
78683       {
78684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78685       };
78686     } catch (std::exception& e) {
78687       {
78688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (Dali::DaliException e) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78693       };
78694     } catch (...) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78697       };
78698     }
78699   }
78700
78701   jresult = result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78708   Dali::Toolkit::TableView::CellPosition arg2 ;
78709   Dali::HorizontalAlignment::Type arg3 ;
78710   Dali::VerticalAlignment::Type arg4 ;
78711   Dali::Toolkit::TableView::CellPosition *argp2 ;
78712
78713   arg1 = (Dali::Toolkit::TableView *)jarg1;
78714   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78715   if (!argp2) {
78716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78717     return ;
78718   }
78719   arg2 = *argp2;
78720   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78721   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78722   {
78723     try {
78724       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78725     } catch (std::out_of_range& e) {
78726       {
78727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78728       };
78729     } catch (std::exception& e) {
78730       {
78731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78732       };
78733     } catch (Dali::DaliException e) {
78734       {
78735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78736       };
78737     } catch (...) {
78738       {
78739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78740       };
78741     }
78742   }
78743
78744 }
78745
78746
78747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78748   unsigned int jresult ;
78749   unsigned int result;
78750
78751   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78752   jresult = result;
78753   return jresult;
78754 }
78755
78756
78757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78758   int jresult ;
78759   int result;
78760
78761   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78762   jresult = (int)result;
78763   return jresult;
78764 }
78765
78766
78767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78768   int jresult ;
78769   int result;
78770
78771   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78772   jresult = (int)result;
78773   return jresult;
78774 }
78775
78776
78777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78778   int jresult ;
78779   int result;
78780
78781   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78782   jresult = (int)result;
78783   return jresult;
78784 }
78785
78786
78787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78788   int jresult ;
78789   int result;
78790
78791   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78792   jresult = (int)result;
78793   return jresult;
78794 }
78795
78796
78797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78798   int jresult ;
78799   int result;
78800
78801   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78802   jresult = (int)result;
78803   return jresult;
78804 }
78805
78806
78807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78808   int jresult ;
78809   int result;
78810
78811   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78812   jresult = (int)result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78818   int jresult ;
78819   int result;
78820
78821   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78822   jresult = (int)result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78828   int jresult ;
78829   int result;
78830
78831   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78832   jresult = (int)result;
78833   return jresult;
78834 }
78835
78836
78837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78838   int jresult ;
78839   int result;
78840
78841   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78842   jresult = (int)result;
78843   return jresult;
78844 }
78845
78846
78847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78848   int jresult ;
78849   int result;
78850
78851   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78852   jresult = (int)result;
78853   return jresult;
78854 }
78855
78856
78857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78858   int jresult ;
78859   int result;
78860
78861   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78862   jresult = (int)result;
78863   return jresult;
78864 }
78865
78866
78867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78868   int jresult ;
78869   int result;
78870
78871   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78872   jresult = (int)result;
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78878   int jresult ;
78879   int result;
78880
78881   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78882   jresult = (int)result;
78883   return jresult;
78884 }
78885
78886
78887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78888   int jresult ;
78889   int result;
78890
78891   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78892   jresult = (int)result;
78893   return jresult;
78894 }
78895
78896
78897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78898   int jresult ;
78899   int result;
78900
78901   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78902   jresult = (int)result;
78903   return jresult;
78904 }
78905
78906
78907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78908   int jresult ;
78909   int result;
78910
78911   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78912   jresult = (int)result;
78913   return jresult;
78914 }
78915
78916
78917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78918   int jresult ;
78919   int result;
78920
78921   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78922   jresult = (int)result;
78923   return jresult;
78924 }
78925
78926
78927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78928   int jresult ;
78929   int result;
78930
78931   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78932   jresult = (int)result;
78933   return jresult;
78934 }
78935
78936
78937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78938   void * jresult ;
78939   Dali::Toolkit::TextLabel::Property *result = 0 ;
78940
78941   {
78942     try {
78943       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78944     } catch (std::out_of_range& e) {
78945       {
78946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78947       };
78948     } catch (std::exception& e) {
78949       {
78950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78951       };
78952     } catch (Dali::DaliException e) {
78953       {
78954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78955       };
78956     } catch (...) {
78957       {
78958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78959       };
78960     }
78961   }
78962
78963   jresult = (void *)result;
78964   return jresult;
78965 }
78966
78967
78968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78969   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78970
78971   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78972   {
78973     try {
78974       delete arg1;
78975     } catch (std::out_of_range& e) {
78976       {
78977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78978       };
78979     } catch (std::exception& e) {
78980       {
78981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78982       };
78983     } catch (Dali::DaliException e) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78986       };
78987     } catch (...) {
78988       {
78989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78990       };
78991     }
78992   }
78993
78994 }
78995
78996
78997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78998   void * jresult ;
78999   Dali::Toolkit::TextLabel result;
79000
79001   {
79002     try {
79003       result = Dali::Toolkit::TextLabel::New();
79004     } catch (std::out_of_range& e) {
79005       {
79006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79007       };
79008     } catch (std::exception& e) {
79009       {
79010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79011       };
79012     } catch (Dali::DaliException e) {
79013       {
79014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79015       };
79016     } catch (...) {
79017       {
79018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79019       };
79020     }
79021   }
79022
79023   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79024   return jresult;
79025 }
79026
79027
79028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79029   void * jresult ;
79030   std::string *arg1 = 0 ;
79031   Dali::Toolkit::TextLabel result;
79032
79033   if (!jarg1) {
79034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79035     return 0;
79036   }
79037   std::string arg1_str(jarg1);
79038   arg1 = &arg1_str;
79039   {
79040     try {
79041       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79042     } catch (std::out_of_range& e) {
79043       {
79044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79045       };
79046     } catch (std::exception& e) {
79047       {
79048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (Dali::DaliException e) {
79051       {
79052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79053       };
79054     } catch (...) {
79055       {
79056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79057       };
79058     }
79059   }
79060
79061   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79062
79063   //argout typemap for const std::string&
79064
79065   return jresult;
79066 }
79067
79068
79069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79070   void * jresult ;
79071   Dali::Toolkit::TextLabel *result = 0 ;
79072
79073   {
79074     try {
79075       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79076     } catch (std::out_of_range& e) {
79077       {
79078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79079       };
79080     } catch (std::exception& e) {
79081       {
79082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79083       };
79084     } catch (Dali::DaliException e) {
79085       {
79086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79087       };
79088     } catch (...) {
79089       {
79090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79091       };
79092     }
79093   }
79094
79095   jresult = (void *)result;
79096   return jresult;
79097 }
79098
79099
79100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79101   void * jresult ;
79102   Dali::Toolkit::TextLabel *arg1 = 0 ;
79103   Dali::Toolkit::TextLabel *result = 0 ;
79104
79105   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79106   if (!arg1) {
79107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79108     return 0;
79109   }
79110   {
79111     try {
79112       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79113     } catch (std::out_of_range& e) {
79114       {
79115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79116       };
79117     } catch (std::exception& e) {
79118       {
79119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79120       };
79121     } catch (Dali::DaliException e) {
79122       {
79123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79124       };
79125     } catch (...) {
79126       {
79127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79128       };
79129     }
79130   }
79131
79132   jresult = (void *)result;
79133   return jresult;
79134 }
79135
79136
79137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79138   void * jresult ;
79139   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79140   Dali::Toolkit::TextLabel *arg2 = 0 ;
79141   Dali::Toolkit::TextLabel *result = 0 ;
79142
79143   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79144   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79145   if (!arg2) {
79146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79147     return 0;
79148   }
79149   {
79150     try {
79151       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79152     } catch (std::out_of_range& e) {
79153       {
79154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79155       };
79156     } catch (std::exception& e) {
79157       {
79158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79159       };
79160     } catch (Dali::DaliException e) {
79161       {
79162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79163       };
79164     } catch (...) {
79165       {
79166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79167       };
79168     }
79169   }
79170
79171   jresult = (void *)result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79177   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79178
79179   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79180   {
79181     try {
79182       delete arg1;
79183     } catch (std::out_of_range& e) {
79184       {
79185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79186       };
79187     } catch (std::exception& e) {
79188       {
79189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79190       };
79191     } catch (Dali::DaliException e) {
79192       {
79193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79194       };
79195     } catch (...) {
79196       {
79197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79198       };
79199     }
79200   }
79201
79202 }
79203
79204
79205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79206   void * jresult ;
79207   Dali::BaseHandle arg1 ;
79208   Dali::BaseHandle *argp1 ;
79209   Dali::Toolkit::TextLabel result;
79210
79211   argp1 = (Dali::BaseHandle *)jarg1;
79212   if (!argp1) {
79213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79214     return 0;
79215   }
79216   arg1 = *argp1;
79217   {
79218     try {
79219       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79220     } catch (std::out_of_range& e) {
79221       {
79222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79223       };
79224     } catch (std::exception& e) {
79225       {
79226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79227       };
79228     } catch (Dali::DaliException e) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79231       };
79232     } catch (...) {
79233       {
79234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79235       };
79236     }
79237   }
79238
79239   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79240   return jresult;
79241 }
79242
79243
79244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79245   void * jresult ;
79246   Dali::Toolkit::AccessibilityManager *result = 0 ;
79247
79248   {
79249     try {
79250       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79251     } catch (std::out_of_range& e) {
79252       {
79253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79254       };
79255     } catch (std::exception& e) {
79256       {
79257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (Dali::DaliException e) {
79260       {
79261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79266       };
79267     }
79268   }
79269
79270   jresult = (void *)result;
79271   return jresult;
79272 }
79273
79274
79275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79277
79278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79279   {
79280     try {
79281       delete arg1;
79282     } catch (std::out_of_range& e) {
79283       {
79284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79285       };
79286     } catch (std::exception& e) {
79287       {
79288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79289       };
79290     } catch (Dali::DaliException e) {
79291       {
79292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79293       };
79294     } catch (...) {
79295       {
79296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79297       };
79298     }
79299   }
79300
79301 }
79302
79303
79304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79305   void * jresult ;
79306   Dali::Toolkit::AccessibilityManager result;
79307
79308   {
79309     try {
79310       result = Dali::Toolkit::AccessibilityManager::Get();
79311     } catch (std::out_of_range& e) {
79312       {
79313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79314       };
79315     } catch (std::exception& e) {
79316       {
79317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79318       };
79319     } catch (Dali::DaliException e) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79322       };
79323     } catch (...) {
79324       {
79325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79326       };
79327     }
79328   }
79329
79330   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79331   return jresult;
79332 }
79333
79334
79335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79336   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79337   Dali::Actor arg2 ;
79338   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79339   std::string *arg4 = 0 ;
79340   Dali::Actor *argp2 ;
79341
79342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79343   argp2 = (Dali::Actor *)jarg2;
79344   if (!argp2) {
79345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79346     return ;
79347   }
79348   arg2 = *argp2;
79349   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79350   if (!jarg4) {
79351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79352     return ;
79353   }
79354   std::string arg4_str(jarg4);
79355   arg4 = &arg4_str;
79356   {
79357     try {
79358       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79359     } catch (std::out_of_range& e) {
79360       {
79361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79362       };
79363     } catch (std::exception& e) {
79364       {
79365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79366       };
79367     } catch (Dali::DaliException e) {
79368       {
79369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79370       };
79371     } catch (...) {
79372       {
79373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79374       };
79375     }
79376   }
79377
79378
79379   //argout typemap for const std::string&
79380
79381 }
79382
79383
79384 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79385   char * jresult ;
79386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79387   Dali::Actor arg2 ;
79388   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79389   Dali::Actor *argp2 ;
79390   std::string result;
79391
79392   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79393   argp2 = (Dali::Actor *)jarg2;
79394   if (!argp2) {
79395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79396     return 0;
79397   }
79398   arg2 = *argp2;
79399   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79400   {
79401     try {
79402       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
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 = SWIG_csharp_string_callback((&result)->c_str());
79423   return jresult;
79424 }
79425
79426
79427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79429   Dali::Actor arg2 ;
79430   unsigned int arg3 ;
79431   Dali::Actor *argp2 ;
79432
79433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79434   argp2 = (Dali::Actor *)jarg2;
79435   if (!argp2) {
79436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79437     return ;
79438   }
79439   arg2 = *argp2;
79440   arg3 = (unsigned int)jarg3;
79441   {
79442     try {
79443       (arg1)->SetFocusOrder(arg2,arg3);
79444     } catch (std::out_of_range& e) {
79445       {
79446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79447       };
79448     } catch (std::exception& e) {
79449       {
79450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79451       };
79452     } catch (Dali::DaliException e) {
79453       {
79454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79455       };
79456     } catch (...) {
79457       {
79458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79459       };
79460     }
79461   }
79462
79463 }
79464
79465
79466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79467   unsigned int jresult ;
79468   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79469   Dali::Actor arg2 ;
79470   Dali::Actor *argp2 ;
79471   unsigned int result;
79472
79473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79474   argp2 = (Dali::Actor *)jarg2;
79475   if (!argp2) {
79476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79477     return 0;
79478   }
79479   arg2 = *argp2;
79480   {
79481     try {
79482       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79483     } catch (std::out_of_range& e) {
79484       {
79485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79486       };
79487     } catch (std::exception& e) {
79488       {
79489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79490       };
79491     } catch (Dali::DaliException e) {
79492       {
79493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79494       };
79495     } catch (...) {
79496       {
79497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79498       };
79499     }
79500   }
79501
79502   jresult = result;
79503   return jresult;
79504 }
79505
79506
79507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79508   unsigned int jresult ;
79509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79510   unsigned int result;
79511
79512   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79513   {
79514     try {
79515       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79516     } catch (std::out_of_range& e) {
79517       {
79518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79519       };
79520     } catch (std::exception& e) {
79521       {
79522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79523       };
79524     } catch (Dali::DaliException e) {
79525       {
79526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79527       };
79528     } catch (...) {
79529       {
79530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79531       };
79532     }
79533   }
79534
79535   jresult = result;
79536   return jresult;
79537 }
79538
79539
79540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79541   void * jresult ;
79542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79543   unsigned int arg2 ;
79544   Dali::Actor result;
79545
79546   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79547   arg2 = (unsigned int)jarg2;
79548   {
79549     try {
79550       result = (arg1)->GetActorByFocusOrder(arg2);
79551     } catch (std::out_of_range& e) {
79552       {
79553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79554       };
79555     } catch (std::exception& e) {
79556       {
79557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79558       };
79559     } catch (Dali::DaliException e) {
79560       {
79561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79562       };
79563     } catch (...) {
79564       {
79565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79566       };
79567     }
79568   }
79569
79570   jresult = new Dali::Actor((const Dali::Actor &)result);
79571   return jresult;
79572 }
79573
79574
79575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79576   unsigned int jresult ;
79577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79578   Dali::Actor arg2 ;
79579   Dali::Actor *argp2 ;
79580   bool result;
79581
79582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79583   argp2 = (Dali::Actor *)jarg2;
79584   if (!argp2) {
79585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79586     return 0;
79587   }
79588   arg2 = *argp2;
79589   {
79590     try {
79591       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79592     } catch (std::out_of_range& e) {
79593       {
79594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79595       };
79596     } catch (std::exception& e) {
79597       {
79598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79599       };
79600     } catch (Dali::DaliException e) {
79601       {
79602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79603       };
79604     } catch (...) {
79605       {
79606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79607       };
79608     }
79609   }
79610
79611   jresult = result;
79612   return jresult;
79613 }
79614
79615
79616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79617   void * jresult ;
79618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79619   Dali::Actor result;
79620
79621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79622   {
79623     try {
79624       result = (arg1)->GetCurrentFocusActor();
79625     } catch (std::out_of_range& e) {
79626       {
79627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79628       };
79629     } catch (std::exception& e) {
79630       {
79631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79632       };
79633     } catch (Dali::DaliException e) {
79634       {
79635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79636       };
79637     } catch (...) {
79638       {
79639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79640       };
79641     }
79642   }
79643
79644   jresult = new Dali::Actor((const Dali::Actor &)result);
79645   return jresult;
79646 }
79647
79648
79649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79650   void * jresult ;
79651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79652   Dali::Actor result;
79653
79654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79655   {
79656     try {
79657       result = (arg1)->GetCurrentFocusGroup();
79658     } catch (std::out_of_range& e) {
79659       {
79660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79661       };
79662     } catch (std::exception& e) {
79663       {
79664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79665       };
79666     } catch (Dali::DaliException e) {
79667       {
79668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79669       };
79670     } catch (...) {
79671       {
79672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79673       };
79674     }
79675   }
79676
79677   jresult = new Dali::Actor((const Dali::Actor &)result);
79678   return jresult;
79679 }
79680
79681
79682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79683   unsigned int jresult ;
79684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79685   unsigned int result;
79686
79687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79688   {
79689     try {
79690       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79691     } catch (std::out_of_range& e) {
79692       {
79693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79694       };
79695     } catch (std::exception& e) {
79696       {
79697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79698       };
79699     } catch (Dali::DaliException e) {
79700       {
79701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79702       };
79703     } catch (...) {
79704       {
79705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79706       };
79707     }
79708   }
79709
79710   jresult = result;
79711   return jresult;
79712 }
79713
79714
79715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79716   unsigned int jresult ;
79717   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79718   bool result;
79719
79720   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79721   {
79722     try {
79723       result = (bool)(arg1)->MoveFocusForward();
79724     } catch (std::out_of_range& e) {
79725       {
79726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79727       };
79728     } catch (std::exception& e) {
79729       {
79730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79731       };
79732     } catch (Dali::DaliException e) {
79733       {
79734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79735       };
79736     } catch (...) {
79737       {
79738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79739       };
79740     }
79741   }
79742
79743   jresult = result;
79744   return jresult;
79745 }
79746
79747
79748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79749   unsigned int jresult ;
79750   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79751   bool result;
79752
79753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79754   {
79755     try {
79756       result = (bool)(arg1)->MoveFocusBackward();
79757     } catch (std::out_of_range& e) {
79758       {
79759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79760       };
79761     } catch (std::exception& e) {
79762       {
79763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79764       };
79765     } catch (Dali::DaliException e) {
79766       {
79767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79768       };
79769     } catch (...) {
79770       {
79771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79772       };
79773     }
79774   }
79775
79776   jresult = result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79783
79784   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79785   {
79786     try {
79787       (arg1)->ClearFocus();
79788     } catch (std::out_of_range& e) {
79789       {
79790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79791       };
79792     } catch (std::exception& e) {
79793       {
79794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79795       };
79796     } catch (Dali::DaliException e) {
79797       {
79798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79799       };
79800     } catch (...) {
79801       {
79802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79803       };
79804     }
79805   }
79806
79807 }
79808
79809
79810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79811   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79812
79813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79814   {
79815     try {
79816       (arg1)->Reset();
79817     } catch (std::out_of_range& e) {
79818       {
79819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79820       };
79821     } catch (std::exception& e) {
79822       {
79823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79824       };
79825     } catch (Dali::DaliException e) {
79826       {
79827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79828       };
79829     } catch (...) {
79830       {
79831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79832       };
79833     }
79834   }
79835
79836 }
79837
79838
79839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79840   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79841   Dali::Actor arg2 ;
79842   bool arg3 ;
79843   Dali::Actor *argp2 ;
79844
79845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79846   argp2 = (Dali::Actor *)jarg2;
79847   if (!argp2) {
79848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79849     return ;
79850   }
79851   arg2 = *argp2;
79852   arg3 = jarg3 ? true : false;
79853   {
79854     try {
79855       (arg1)->SetFocusGroup(arg2,arg3);
79856     } catch (std::out_of_range& e) {
79857       {
79858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79859       };
79860     } catch (std::exception& e) {
79861       {
79862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79863       };
79864     } catch (Dali::DaliException e) {
79865       {
79866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79867       };
79868     } catch (...) {
79869       {
79870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79871       };
79872     }
79873   }
79874
79875 }
79876
79877
79878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79879   unsigned int jresult ;
79880   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79881   Dali::Actor arg2 ;
79882   Dali::Actor *argp2 ;
79883   bool result;
79884
79885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79886   argp2 = (Dali::Actor *)jarg2;
79887   if (!argp2) {
79888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79889     return 0;
79890   }
79891   arg2 = *argp2;
79892   {
79893     try {
79894       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79895     } catch (std::out_of_range& e) {
79896       {
79897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79898       };
79899     } catch (std::exception& e) {
79900       {
79901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (Dali::DaliException e) {
79904       {
79905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79906       };
79907     } catch (...) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79910       };
79911     }
79912   }
79913
79914   jresult = result;
79915   return jresult;
79916 }
79917
79918
79919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79921   bool arg2 ;
79922
79923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79924   arg2 = jarg2 ? true : false;
79925   {
79926     try {
79927       (arg1)->SetGroupMode(arg2);
79928     } catch (std::out_of_range& e) {
79929       {
79930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79931       };
79932     } catch (std::exception& e) {
79933       {
79934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79935       };
79936     } catch (Dali::DaliException e) {
79937       {
79938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79939       };
79940     } catch (...) {
79941       {
79942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79943       };
79944     }
79945   }
79946
79947 }
79948
79949
79950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79951   unsigned int jresult ;
79952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79953   bool result;
79954
79955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79956   {
79957     try {
79958       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79959     } catch (std::out_of_range& e) {
79960       {
79961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79962       };
79963     } catch (std::exception& e) {
79964       {
79965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79966       };
79967     } catch (Dali::DaliException e) {
79968       {
79969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79970       };
79971     } catch (...) {
79972       {
79973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79974       };
79975     }
79976   }
79977
79978   jresult = result;
79979   return jresult;
79980 }
79981
79982
79983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79985   bool arg2 ;
79986
79987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79988   arg2 = jarg2 ? true : false;
79989   {
79990     try {
79991       (arg1)->SetWrapMode(arg2);
79992     } catch (std::out_of_range& e) {
79993       {
79994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79995       };
79996     } catch (std::exception& e) {
79997       {
79998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79999       };
80000     } catch (Dali::DaliException e) {
80001       {
80002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80003       };
80004     } catch (...) {
80005       {
80006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80007       };
80008     }
80009   }
80010
80011 }
80012
80013
80014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80015   unsigned int jresult ;
80016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80017   bool result;
80018
80019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80020   {
80021     try {
80022       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80023     } catch (std::out_of_range& e) {
80024       {
80025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80026       };
80027     } catch (std::exception& e) {
80028       {
80029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80030       };
80031     } catch (Dali::DaliException e) {
80032       {
80033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80034       };
80035     } catch (...) {
80036       {
80037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80038       };
80039     }
80040   }
80041
80042   jresult = result;
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80049   Dali::Actor arg2 ;
80050   Dali::Actor *argp2 ;
80051
80052   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80053   argp2 = (Dali::Actor *)jarg2;
80054   if (!argp2) {
80055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80056     return ;
80057   }
80058   arg2 = *argp2;
80059   {
80060     try {
80061       (arg1)->SetFocusIndicatorActor(arg2);
80062     } catch (std::out_of_range& e) {
80063       {
80064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80065       };
80066     } catch (std::exception& e) {
80067       {
80068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80069       };
80070     } catch (Dali::DaliException e) {
80071       {
80072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80073       };
80074     } catch (...) {
80075       {
80076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80077       };
80078     }
80079   }
80080
80081 }
80082
80083
80084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80085   void * jresult ;
80086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80087   Dali::Actor result;
80088
80089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80090   {
80091     try {
80092       result = (arg1)->GetFocusIndicatorActor();
80093     } catch (std::out_of_range& e) {
80094       {
80095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80096       };
80097     } catch (std::exception& e) {
80098       {
80099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80100       };
80101     } catch (Dali::DaliException e) {
80102       {
80103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80104       };
80105     } catch (...) {
80106       {
80107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80108       };
80109     }
80110   }
80111
80112   jresult = new Dali::Actor((const Dali::Actor &)result);
80113   return jresult;
80114 }
80115
80116
80117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80118   void * jresult ;
80119   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80120   Dali::Actor arg2 ;
80121   Dali::Actor *argp2 ;
80122   Dali::Actor result;
80123
80124   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80125   argp2 = (Dali::Actor *)jarg2;
80126   if (!argp2) {
80127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80128     return 0;
80129   }
80130   arg2 = *argp2;
80131   {
80132     try {
80133       result = (arg1)->GetFocusGroup(arg2);
80134     } catch (std::out_of_range& e) {
80135       {
80136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80137       };
80138     } catch (std::exception& e) {
80139       {
80140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80141       };
80142     } catch (Dali::DaliException e) {
80143       {
80144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80145       };
80146     } catch (...) {
80147       {
80148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80149       };
80150     }
80151   }
80152
80153   jresult = new Dali::Actor((const Dali::Actor &)result);
80154   return jresult;
80155 }
80156
80157
80158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80159   void * jresult ;
80160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80161   Dali::Vector2 result;
80162
80163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80164   {
80165     try {
80166       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80167     } catch (std::out_of_range& e) {
80168       {
80169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80170       };
80171     } catch (std::exception& e) {
80172       {
80173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80174       };
80175     } catch (Dali::DaliException e) {
80176       {
80177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80178       };
80179     } catch (...) {
80180       {
80181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80182       };
80183     }
80184   }
80185
80186   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80187   return jresult;
80188 }
80189
80190
80191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80192   void * jresult ;
80193   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80194   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80195
80196   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80197   {
80198     try {
80199       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80200     } catch (std::out_of_range& e) {
80201       {
80202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80203       };
80204     } catch (std::exception& e) {
80205       {
80206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80207       };
80208     } catch (Dali::DaliException e) {
80209       {
80210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80211       };
80212     } catch (...) {
80213       {
80214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80215       };
80216     }
80217   }
80218
80219   jresult = (void *)result;
80220   return jresult;
80221 }
80222
80223
80224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80225   void * jresult ;
80226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80227   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80228
80229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80230   {
80231     try {
80232       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80233     } catch (std::out_of_range& e) {
80234       {
80235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (std::exception& e) {
80238       {
80239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80240       };
80241     } catch (Dali::DaliException e) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80244       };
80245     } catch (...) {
80246       {
80247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80248       };
80249     }
80250   }
80251
80252   jresult = (void *)result;
80253   return jresult;
80254 }
80255
80256
80257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80258   void * jresult ;
80259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80260   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80261
80262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80263   {
80264     try {
80265       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80266     } catch (std::out_of_range& e) {
80267       {
80268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80269       };
80270     } catch (std::exception& e) {
80271       {
80272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80273       };
80274     } catch (Dali::DaliException e) {
80275       {
80276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80277       };
80278     } catch (...) {
80279       {
80280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80281       };
80282     }
80283   }
80284
80285   jresult = (void *)result;
80286   return jresult;
80287 }
80288
80289
80290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80291   void * jresult ;
80292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80293   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80294
80295   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80296   {
80297     try {
80298       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80299     } catch (std::out_of_range& e) {
80300       {
80301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80302       };
80303     } catch (std::exception& e) {
80304       {
80305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80306       };
80307     } catch (Dali::DaliException e) {
80308       {
80309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80310       };
80311     } catch (...) {
80312       {
80313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80314       };
80315     }
80316   }
80317
80318   jresult = (void *)result;
80319   return jresult;
80320 }
80321
80322
80323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80324   void * jresult ;
80325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80326   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80327
80328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80329   {
80330     try {
80331       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80339       };
80340     } catch (Dali::DaliException e) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80343       };
80344     } catch (...) {
80345       {
80346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80347       };
80348     }
80349   }
80350
80351   jresult = (void *)result;
80352   return jresult;
80353 }
80354
80355
80356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80357   void * jresult ;
80358   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80359   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80360
80361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80362   {
80363     try {
80364       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80365     } catch (std::out_of_range& e) {
80366       {
80367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80368       };
80369     } catch (std::exception& e) {
80370       {
80371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80372       };
80373     } catch (Dali::DaliException e) {
80374       {
80375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80376       };
80377     } catch (...) {
80378       {
80379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80380       };
80381     }
80382   }
80383
80384   jresult = (void *)result;
80385   return jresult;
80386 }
80387
80388
80389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80390   void * jresult ;
80391   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80392   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80393
80394   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80395   {
80396     try {
80397       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80398     } catch (std::out_of_range& e) {
80399       {
80400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80401       };
80402     } catch (std::exception& e) {
80403       {
80404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80405       };
80406     } catch (Dali::DaliException e) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80409       };
80410     } catch (...) {
80411       {
80412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80413       };
80414     }
80415   }
80416
80417   jresult = (void *)result;
80418   return jresult;
80419 }
80420
80421
80422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80423   void * jresult ;
80424   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80425   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80426
80427   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80428   {
80429     try {
80430       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80431     } catch (std::out_of_range& e) {
80432       {
80433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80434       };
80435     } catch (std::exception& e) {
80436       {
80437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80438       };
80439     } catch (Dali::DaliException e) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80442       };
80443     } catch (...) {
80444       {
80445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80446       };
80447     }
80448   }
80449
80450   jresult = (void *)result;
80451   return jresult;
80452 }
80453
80454
80455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80456   void * jresult ;
80457   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80458   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80459
80460   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80461   {
80462     try {
80463       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80464     } catch (std::out_of_range& e) {
80465       {
80466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80467       };
80468     } catch (std::exception& e) {
80469       {
80470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80471       };
80472     } catch (Dali::DaliException e) {
80473       {
80474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80475       };
80476     } catch (...) {
80477       {
80478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80479       };
80480     }
80481   }
80482
80483   jresult = (void *)result;
80484   return jresult;
80485 }
80486
80487
80488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80489   void * jresult ;
80490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80491   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80492
80493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80494   {
80495     try {
80496       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80497     } catch (std::out_of_range& e) {
80498       {
80499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (std::exception& e) {
80502       {
80503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (Dali::DaliException e) {
80506       {
80507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80508       };
80509     } catch (...) {
80510       {
80511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80512       };
80513     }
80514   }
80515
80516   jresult = (void *)result;
80517   return jresult;
80518 }
80519
80520
80521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80522   void * jresult ;
80523   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80524   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80525
80526   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80527   {
80528     try {
80529       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80530     } catch (std::out_of_range& e) {
80531       {
80532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80533       };
80534     } catch (std::exception& e) {
80535       {
80536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80537       };
80538     } catch (Dali::DaliException e) {
80539       {
80540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80541       };
80542     } catch (...) {
80543       {
80544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80545       };
80546     }
80547   }
80548
80549   jresult = (void *)result;
80550   return jresult;
80551 }
80552
80553
80554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80555   void * jresult ;
80556   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80557   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80558
80559   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80560   {
80561     try {
80562       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80563     } catch (std::out_of_range& e) {
80564       {
80565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80566       };
80567     } catch (std::exception& e) {
80568       {
80569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80570       };
80571     } catch (Dali::DaliException e) {
80572       {
80573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80574       };
80575     } catch (...) {
80576       {
80577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80578       };
80579     }
80580   }
80581
80582   jresult = (void *)result;
80583   return jresult;
80584 }
80585
80586
80587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80588   void * jresult ;
80589   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80590   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80591
80592   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80593   {
80594     try {
80595       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80596     } catch (std::out_of_range& e) {
80597       {
80598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80599       };
80600     } catch (std::exception& e) {
80601       {
80602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80603       };
80604     } catch (Dali::DaliException e) {
80605       {
80606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80607       };
80608     } catch (...) {
80609       {
80610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80611       };
80612     }
80613   }
80614
80615   jresult = (void *)result;
80616   return jresult;
80617 }
80618
80619
80620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80621   void * jresult ;
80622   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80623   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80624
80625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80626   {
80627     try {
80628       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80629     } catch (std::out_of_range& e) {
80630       {
80631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80632       };
80633     } catch (std::exception& e) {
80634       {
80635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80636       };
80637     } catch (Dali::DaliException e) {
80638       {
80639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80640       };
80641     } catch (...) {
80642       {
80643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80644       };
80645     }
80646   }
80647
80648   jresult = (void *)result;
80649   return jresult;
80650 }
80651
80652
80653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80654   void * jresult ;
80655   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80656   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80657
80658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80659   {
80660     try {
80661       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80662     } catch (std::out_of_range& e) {
80663       {
80664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80665       };
80666     } catch (std::exception& e) {
80667       {
80668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80669       };
80670     } catch (Dali::DaliException e) {
80671       {
80672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80673       };
80674     } catch (...) {
80675       {
80676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80677       };
80678     }
80679   }
80680
80681   jresult = (void *)result;
80682   return jresult;
80683 }
80684
80685
80686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80687   void * jresult ;
80688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80689   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80690
80691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80692   {
80693     try {
80694       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80695     } catch (std::out_of_range& e) {
80696       {
80697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80698       };
80699     } catch (std::exception& e) {
80700       {
80701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80702       };
80703     } catch (Dali::DaliException e) {
80704       {
80705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80706       };
80707     } catch (...) {
80708       {
80709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80710       };
80711     }
80712   }
80713
80714   jresult = (void *)result;
80715   return jresult;
80716 }
80717
80718
80719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80720   void * jresult ;
80721   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80722   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80723
80724   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80725   {
80726     try {
80727       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80728     } catch (std::out_of_range& e) {
80729       {
80730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80731       };
80732     } catch (std::exception& e) {
80733       {
80734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80735       };
80736     } catch (Dali::DaliException e) {
80737       {
80738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80739       };
80740     } catch (...) {
80741       {
80742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80743       };
80744     }
80745   }
80746
80747   jresult = (void *)result;
80748   return jresult;
80749 }
80750
80751
80752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80753   void * jresult ;
80754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80755   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80756
80757   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80758   {
80759     try {
80760       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80761     } catch (std::out_of_range& e) {
80762       {
80763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80764       };
80765     } catch (std::exception& e) {
80766       {
80767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80768       };
80769     } catch (Dali::DaliException e) {
80770       {
80771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80772       };
80773     } catch (...) {
80774       {
80775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80776       };
80777     }
80778   }
80779
80780   jresult = (void *)result;
80781   return jresult;
80782 }
80783
80784
80785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80786   void * jresult ;
80787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80789
80790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80791   {
80792     try {
80793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80794     } catch (std::out_of_range& e) {
80795       {
80796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80797       };
80798     } catch (std::exception& e) {
80799       {
80800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80801       };
80802     } catch (Dali::DaliException e) {
80803       {
80804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80805       };
80806     } catch (...) {
80807       {
80808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80809       };
80810     }
80811   }
80812
80813   jresult = (void *)result;
80814   return jresult;
80815 }
80816
80817
80818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80819   void * jresult ;
80820   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80821   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80822
80823   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80824   {
80825     try {
80826       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80827     } catch (std::out_of_range& e) {
80828       {
80829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80830       };
80831     } catch (std::exception& e) {
80832       {
80833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80834       };
80835     } catch (Dali::DaliException e) {
80836       {
80837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80838       };
80839     } catch (...) {
80840       {
80841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80842       };
80843     }
80844   }
80845
80846   jresult = (void *)result;
80847   return jresult;
80848 }
80849
80850
80851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80852   void * jresult ;
80853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80854   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80855
80856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80857   {
80858     try {
80859       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80860     } catch (std::out_of_range& e) {
80861       {
80862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80863       };
80864     } catch (std::exception& e) {
80865       {
80866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80867       };
80868     } catch (Dali::DaliException e) {
80869       {
80870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80871       };
80872     } catch (...) {
80873       {
80874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80875       };
80876     }
80877   }
80878
80879   jresult = (void *)result;
80880   return jresult;
80881 }
80882
80883
80884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80885   void * jresult ;
80886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80887   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80888
80889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80890   {
80891     try {
80892       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80893     } catch (std::out_of_range& e) {
80894       {
80895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80896       };
80897     } catch (std::exception& e) {
80898       {
80899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (Dali::DaliException e) {
80902       {
80903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80904       };
80905     } catch (...) {
80906       {
80907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80908       };
80909     }
80910   }
80911
80912   jresult = (void *)result;
80913   return jresult;
80914 }
80915
80916
80917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80918   void * jresult ;
80919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80920   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80921
80922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80923   {
80924     try {
80925       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80926     } catch (std::out_of_range& e) {
80927       {
80928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80929       };
80930     } catch (std::exception& e) {
80931       {
80932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80933       };
80934     } catch (Dali::DaliException e) {
80935       {
80936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80937       };
80938     } catch (...) {
80939       {
80940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80941       };
80942     }
80943   }
80944
80945   jresult = (void *)result;
80946   return jresult;
80947 }
80948
80949
80950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80951   void * jresult ;
80952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80953   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80954
80955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80956   {
80957     try {
80958       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80959     } catch (std::out_of_range& e) {
80960       {
80961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80962       };
80963     } catch (std::exception& e) {
80964       {
80965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80966       };
80967     } catch (Dali::DaliException e) {
80968       {
80969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80970       };
80971     } catch (...) {
80972       {
80973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80974       };
80975     }
80976   }
80977
80978   jresult = (void *)result;
80979   return jresult;
80980 }
80981
80982
80983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80984   void * jresult ;
80985   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80986   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80987
80988   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80989   {
80990     try {
80991       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80992     } catch (std::out_of_range& e) {
80993       {
80994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80995       };
80996     } catch (std::exception& e) {
80997       {
80998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80999       };
81000     } catch (Dali::DaliException e) {
81001       {
81002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81003       };
81004     } catch (...) {
81005       {
81006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81007       };
81008     }
81009   }
81010
81011   jresult = (void *)result;
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81017   void * jresult ;
81018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81019   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81020
81021   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81022   {
81023     try {
81024       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81025     } catch (std::out_of_range& e) {
81026       {
81027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81028       };
81029     } catch (std::exception& e) {
81030       {
81031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81032       };
81033     } catch (Dali::DaliException e) {
81034       {
81035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81036       };
81037     } catch (...) {
81038       {
81039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81040       };
81041     }
81042   }
81043
81044   jresult = (void *)result;
81045   return jresult;
81046 }
81047
81048
81049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81050   void * jresult ;
81051   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81052   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81053
81054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81055   {
81056     try {
81057       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81058     } catch (std::out_of_range& e) {
81059       {
81060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81061       };
81062     } catch (std::exception& e) {
81063       {
81064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81065       };
81066     } catch (Dali::DaliException e) {
81067       {
81068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81069       };
81070     } catch (...) {
81071       {
81072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81073       };
81074     }
81075   }
81076
81077   jresult = (void *)result;
81078   return jresult;
81079 }
81080
81081
81082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81083   void * jresult ;
81084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81085   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81086
81087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81088   {
81089     try {
81090       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81091     } catch (std::out_of_range& e) {
81092       {
81093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81094       };
81095     } catch (std::exception& e) {
81096       {
81097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81098       };
81099     } catch (Dali::DaliException e) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81102       };
81103     } catch (...) {
81104       {
81105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81106       };
81107     }
81108   }
81109
81110   jresult = (void *)result;
81111   return jresult;
81112 }
81113
81114
81115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81116   void * jresult ;
81117   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81118   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81119
81120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81121   {
81122     try {
81123       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81124     } catch (std::out_of_range& e) {
81125       {
81126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81127       };
81128     } catch (std::exception& e) {
81129       {
81130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81131       };
81132     } catch (Dali::DaliException e) {
81133       {
81134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81135       };
81136     } catch (...) {
81137       {
81138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81139       };
81140     }
81141   }
81142
81143   jresult = (void *)result;
81144   return jresult;
81145 }
81146
81147
81148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81149   void * jresult ;
81150   Dali::Toolkit::StyleManager *result = 0 ;
81151
81152   {
81153     try {
81154       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81155     } catch (std::out_of_range& e) {
81156       {
81157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81158       };
81159     } catch (std::exception& e) {
81160       {
81161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81162       };
81163     } catch (Dali::DaliException e) {
81164       {
81165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81166       };
81167     } catch (...) {
81168       {
81169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81170       };
81171     }
81172   }
81173
81174   jresult = (void *)result;
81175   return jresult;
81176 }
81177
81178
81179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81180   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81181
81182   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81183   {
81184     try {
81185       delete arg1;
81186     } catch (std::out_of_range& e) {
81187       {
81188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81189       };
81190     } catch (std::exception& e) {
81191       {
81192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81193       };
81194     } catch (Dali::DaliException e) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81197       };
81198     } catch (...) {
81199       {
81200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81201       };
81202     }
81203   }
81204
81205 }
81206
81207
81208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81209   void * jresult ;
81210   Dali::Toolkit::StyleManager result;
81211
81212   {
81213     try {
81214       result = Dali::Toolkit::StyleManager::Get();
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81222       };
81223     } catch (Dali::DaliException e) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81230       };
81231     }
81232   }
81233
81234   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81235   return jresult;
81236 }
81237
81238
81239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81240   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81241   std::string *arg2 = 0 ;
81242
81243   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81244   if (!jarg2) {
81245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81246     return ;
81247   }
81248   std::string arg2_str(jarg2);
81249   arg2 = &arg2_str;
81250   {
81251     try {
81252       (arg1)->ApplyTheme((std::string const &)*arg2);
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81260       };
81261     } catch (Dali::DaliException e) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81264       };
81265     } catch (...) {
81266       {
81267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81268       };
81269     }
81270   }
81271
81272
81273   //argout typemap for const std::string&
81274
81275 }
81276
81277
81278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81279   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81280
81281   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81282   {
81283     try {
81284       (arg1)->ApplyDefaultTheme();
81285     } catch (std::out_of_range& e) {
81286       {
81287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81288       };
81289     } catch (std::exception& e) {
81290       {
81291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81292       };
81293     } catch (Dali::DaliException e) {
81294       {
81295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81296       };
81297     } catch (...) {
81298       {
81299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81300       };
81301     }
81302   }
81303
81304 }
81305
81306
81307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81308   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81309   std::string *arg2 = 0 ;
81310   Dali::Property::Value *arg3 = 0 ;
81311
81312   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81313   if (!jarg2) {
81314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81315     return ;
81316   }
81317   std::string arg2_str(jarg2);
81318   arg2 = &arg2_str;
81319   arg3 = (Dali::Property::Value *)jarg3;
81320   if (!arg3) {
81321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81322     return ;
81323   }
81324   {
81325     try {
81326       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81327     } catch (std::out_of_range& e) {
81328       {
81329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81330       };
81331     } catch (std::exception& e) {
81332       {
81333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81334       };
81335     } catch (Dali::DaliException e) {
81336       {
81337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81338       };
81339     } catch (...) {
81340       {
81341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81342       };
81343     }
81344   }
81345
81346
81347   //argout typemap for const std::string&
81348
81349 }
81350
81351
81352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81353   unsigned int jresult ;
81354   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81355   std::string *arg2 = 0 ;
81356   Dali::Property::Value *arg3 = 0 ;
81357   bool result;
81358
81359   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81360   if (!jarg2) {
81361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81362     return 0;
81363   }
81364   std::string arg2_str(jarg2);
81365   arg2 = &arg2_str;
81366   arg3 = (Dali::Property::Value *)jarg3;
81367   if (!arg3) {
81368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81369     return 0;
81370   }
81371   {
81372     try {
81373       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81374     } catch (std::out_of_range& e) {
81375       {
81376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81377       };
81378     } catch (std::exception& e) {
81379       {
81380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81381       };
81382     } catch (Dali::DaliException e) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81385       };
81386     } catch (...) {
81387       {
81388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81389       };
81390     }
81391   }
81392
81393   jresult = result;
81394
81395   //argout typemap for const std::string&
81396
81397   return jresult;
81398 }
81399
81400
81401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81402   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81403   Dali::Toolkit::Control arg2 ;
81404   std::string *arg3 = 0 ;
81405   std::string *arg4 = 0 ;
81406   Dali::Toolkit::Control *argp2 ;
81407
81408   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81409   argp2 = (Dali::Toolkit::Control *)jarg2;
81410   if (!argp2) {
81411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81412     return ;
81413   }
81414   arg2 = *argp2;
81415   if (!jarg3) {
81416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81417     return ;
81418   }
81419   std::string arg3_str(jarg3);
81420   arg3 = &arg3_str;
81421   if (!jarg4) {
81422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81423     return ;
81424   }
81425   std::string arg4_str(jarg4);
81426   arg4 = &arg4_str;
81427   {
81428     try {
81429       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81430     } catch (std::out_of_range& e) {
81431       {
81432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81433       };
81434     } catch (std::exception& e) {
81435       {
81436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81437       };
81438     } catch (Dali::DaliException e) {
81439       {
81440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81441       };
81442     } catch (...) {
81443       {
81444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81445       };
81446     }
81447   }
81448
81449
81450   //argout typemap for const std::string&
81451
81452
81453   //argout typemap for const std::string&
81454
81455 }
81456
81457
81458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81459   void * jresult ;
81460   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81461   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81462
81463   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81464   {
81465     try {
81466       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81467     } catch (std::out_of_range& e) {
81468       {
81469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81470       };
81471     } catch (std::exception& e) {
81472       {
81473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81474       };
81475     } catch (Dali::DaliException e) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81478       };
81479     } catch (...) {
81480       {
81481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81482       };
81483     }
81484   }
81485
81486   jresult = (void *)result;
81487   return jresult;
81488 }
81489
81490
81491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81492   int jresult ;
81493   int result;
81494
81495   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81496   jresult = (int)result;
81497   return jresult;
81498 }
81499
81500
81501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81502   int jresult ;
81503   int result;
81504
81505   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81506   jresult = (int)result;
81507   return jresult;
81508 }
81509
81510
81511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81512   int jresult ;
81513   int result;
81514
81515   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81516   jresult = (int)result;
81517   return jresult;
81518 }
81519
81520
81521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81522   int jresult ;
81523   int result;
81524
81525   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81526   jresult = (int)result;
81527   return jresult;
81528 }
81529
81530
81531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81532   int jresult ;
81533   int result;
81534
81535   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81536   jresult = (int)result;
81537   return jresult;
81538 }
81539
81540
81541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81542   int jresult ;
81543   int result;
81544
81545   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81546   jresult = (int)result;
81547   return jresult;
81548 }
81549
81550
81551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81552   int jresult ;
81553   int result;
81554
81555   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81556   jresult = (int)result;
81557   return jresult;
81558 }
81559
81560
81561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81562   int jresult ;
81563   int result;
81564
81565   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81566   jresult = (int)result;
81567   return jresult;
81568 }
81569
81570
81571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81572   int jresult ;
81573   int result;
81574
81575   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81576   jresult = (int)result;
81577   return jresult;
81578 }
81579
81580
81581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81582   int jresult ;
81583   int result;
81584
81585   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81586   jresult = (int)result;
81587   return jresult;
81588 }
81589
81590
81591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81592   int jresult ;
81593   int result;
81594
81595   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81596   jresult = (int)result;
81597   return jresult;
81598 }
81599
81600
81601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81602   int jresult ;
81603   int result;
81604
81605   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81606   jresult = (int)result;
81607   return jresult;
81608 }
81609
81610
81611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81612   int jresult ;
81613   int result;
81614
81615   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81616   jresult = (int)result;
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81622   int jresult ;
81623   int result;
81624
81625   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81626   jresult = (int)result;
81627   return jresult;
81628 }
81629
81630
81631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81632   int jresult ;
81633   int result;
81634
81635   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81636   jresult = (int)result;
81637   return jresult;
81638 }
81639
81640
81641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81642   void * jresult ;
81643   Dali::Toolkit::Slider::Property *result = 0 ;
81644
81645   {
81646     try {
81647       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81648     } catch (std::out_of_range& e) {
81649       {
81650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81651       };
81652     } catch (std::exception& e) {
81653       {
81654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81655       };
81656     } catch (Dali::DaliException e) {
81657       {
81658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81659       };
81660     } catch (...) {
81661       {
81662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81663       };
81664     }
81665   }
81666
81667   jresult = (void *)result;
81668   return jresult;
81669 }
81670
81671
81672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81673   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81674
81675   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81676   {
81677     try {
81678       delete arg1;
81679     } catch (std::out_of_range& e) {
81680       {
81681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81682       };
81683     } catch (std::exception& e) {
81684       {
81685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81686       };
81687     } catch (Dali::DaliException e) {
81688       {
81689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81690       };
81691     } catch (...) {
81692       {
81693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81694       };
81695     }
81696   }
81697
81698 }
81699
81700
81701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81702   void * jresult ;
81703   Dali::Toolkit::Slider result;
81704
81705   {
81706     try {
81707       result = Dali::Toolkit::Slider::New();
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 = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81728   return jresult;
81729 }
81730
81731
81732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81733   void * jresult ;
81734   Dali::Toolkit::Slider *result = 0 ;
81735
81736   {
81737     try {
81738       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81739     } catch (std::out_of_range& e) {
81740       {
81741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81742       };
81743     } catch (std::exception& e) {
81744       {
81745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81746       };
81747     } catch (Dali::DaliException e) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81750       };
81751     } catch (...) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81754       };
81755     }
81756   }
81757
81758   jresult = (void *)result;
81759   return jresult;
81760 }
81761
81762
81763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81764   void * jresult ;
81765   Dali::Toolkit::Slider *arg1 = 0 ;
81766   Dali::Toolkit::Slider *result = 0 ;
81767
81768   arg1 = (Dali::Toolkit::Slider *)jarg1;
81769   if (!arg1) {
81770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81771     return 0;
81772   }
81773   {
81774     try {
81775       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81776     } catch (std::out_of_range& e) {
81777       {
81778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81779       };
81780     } catch (std::exception& e) {
81781       {
81782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81783       };
81784     } catch (Dali::DaliException e) {
81785       {
81786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81787       };
81788     } catch (...) {
81789       {
81790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81791       };
81792     }
81793   }
81794
81795   jresult = (void *)result;
81796   return jresult;
81797 }
81798
81799
81800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81801   void * jresult ;
81802   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81803   Dali::Toolkit::Slider *arg2 = 0 ;
81804   Dali::Toolkit::Slider *result = 0 ;
81805
81806   arg1 = (Dali::Toolkit::Slider *)jarg1;
81807   arg2 = (Dali::Toolkit::Slider *)jarg2;
81808   if (!arg2) {
81809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81810     return 0;
81811   }
81812   {
81813     try {
81814       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81815     } catch (std::out_of_range& e) {
81816       {
81817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81818       };
81819     } catch (std::exception& e) {
81820       {
81821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81822       };
81823     } catch (Dali::DaliException e) {
81824       {
81825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81826       };
81827     } catch (...) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81830       };
81831     }
81832   }
81833
81834   jresult = (void *)result;
81835   return jresult;
81836 }
81837
81838
81839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81840   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81841
81842   arg1 = (Dali::Toolkit::Slider *)jarg1;
81843   {
81844     try {
81845       delete arg1;
81846     } catch (std::out_of_range& e) {
81847       {
81848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81849       };
81850     } catch (std::exception& e) {
81851       {
81852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81853       };
81854     } catch (Dali::DaliException e) {
81855       {
81856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81857       };
81858     } catch (...) {
81859       {
81860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81861       };
81862     }
81863   }
81864
81865 }
81866
81867
81868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81869   void * jresult ;
81870   Dali::BaseHandle arg1 ;
81871   Dali::BaseHandle *argp1 ;
81872   Dali::Toolkit::Slider result;
81873
81874   argp1 = (Dali::BaseHandle *)jarg1;
81875   if (!argp1) {
81876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81877     return 0;
81878   }
81879   arg1 = *argp1;
81880   {
81881     try {
81882       result = Dali::Toolkit::Slider::DownCast(arg1);
81883     } catch (std::out_of_range& e) {
81884       {
81885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81886       };
81887     } catch (std::exception& e) {
81888       {
81889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81890       };
81891     } catch (Dali::DaliException e) {
81892       {
81893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81894       };
81895     } catch (...) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81898       };
81899     }
81900   }
81901
81902   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81903   return jresult;
81904 }
81905
81906
81907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81908   void * jresult ;
81909   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81910   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81911
81912   arg1 = (Dali::Toolkit::Slider *)jarg1;
81913   {
81914     try {
81915       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81923       };
81924     } catch (Dali::DaliException e) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81927       };
81928     } catch (...) {
81929       {
81930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81931       };
81932     }
81933   }
81934
81935   jresult = (void *)result;
81936   return jresult;
81937 }
81938
81939
81940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81941   void * jresult ;
81942   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81943   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81944
81945   arg1 = (Dali::Toolkit::Slider *)jarg1;
81946   {
81947     try {
81948       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (Dali::DaliException e) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81964       };
81965     }
81966   }
81967
81968   jresult = (void *)result;
81969   return jresult;
81970 }
81971
81972
81973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81974   void * jresult ;
81975   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81976   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81977
81978   arg1 = (Dali::Toolkit::Slider *)jarg1;
81979   {
81980     try {
81981       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81982     } catch (std::out_of_range& e) {
81983       {
81984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81985       };
81986     } catch (std::exception& e) {
81987       {
81988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81989       };
81990     } catch (Dali::DaliException e) {
81991       {
81992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81997       };
81998     }
81999   }
82000
82001   jresult = (void *)result;
82002   return jresult;
82003 }
82004
82005
82006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82007   int jresult ;
82008   int result;
82009
82010   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82011   jresult = (int)result;
82012   return jresult;
82013 }
82014
82015
82016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82017   int jresult ;
82018   int result;
82019
82020   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82021   jresult = (int)result;
82022   return jresult;
82023 }
82024
82025
82026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82027   int jresult ;
82028   int result;
82029
82030   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82031   jresult = (int)result;
82032   return jresult;
82033 }
82034
82035
82036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82037   int jresult ;
82038   int result;
82039
82040   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82041   jresult = (int)result;
82042   return jresult;
82043 }
82044
82045
82046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
82047   int result;
82048
82049   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
82050
82051   return result;
82052 }
82053
82054
82055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82056   void * jresult ;
82057   Dali::Toolkit::VideoView::Property *result = 0 ;
82058
82059   {
82060     try {
82061       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82062     } catch (std::out_of_range& e) {
82063       {
82064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82065       };
82066     } catch (std::exception& e) {
82067       {
82068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82069       };
82070     } catch (Dali::DaliException e) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82073       };
82074     } catch (...) {
82075       {
82076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82077       };
82078     }
82079   }
82080
82081   jresult = (void *)result;
82082   return jresult;
82083 }
82084
82085
82086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82087   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82088
82089   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82090   {
82091     try {
82092       delete arg1;
82093     } catch (std::out_of_range& e) {
82094       {
82095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82096       };
82097     } catch (std::exception& e) {
82098       {
82099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82100       };
82101     } catch (Dali::DaliException e) {
82102       {
82103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82104       };
82105     } catch (...) {
82106       {
82107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82108       };
82109     }
82110   }
82111
82112 }
82113
82114
82115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82116   void * jresult ;
82117   Dali::Toolkit::VideoView result;
82118
82119   {
82120     try {
82121       result = Dali::Toolkit::VideoView::New();
82122     } catch (std::out_of_range& e) {
82123       {
82124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82125       };
82126     } catch (std::exception& e) {
82127       {
82128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82129       };
82130     } catch (Dali::DaliException e) {
82131       {
82132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82133       };
82134     } catch (...) {
82135       {
82136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82137       };
82138     }
82139   }
82140
82141   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82142   return jresult;
82143 }
82144
82145
82146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82147   void * jresult ;
82148   std::string *arg1 = 0 ;
82149   Dali::Toolkit::VideoView result;
82150
82151   if (!jarg1) {
82152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82153     return 0;
82154   }
82155   std::string arg1_str(jarg1);
82156   arg1 = &arg1_str;
82157   {
82158     try {
82159       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82160     } catch (std::out_of_range& e) {
82161       {
82162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82163       };
82164     } catch (std::exception& e) {
82165       {
82166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82167       };
82168     } catch (Dali::DaliException e) {
82169       {
82170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82171       };
82172     } catch (...) {
82173       {
82174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82175       };
82176     }
82177   }
82178
82179   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82180
82181   //argout typemap for const std::string&
82182
82183   return jresult;
82184 }
82185
82186
82187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82188   void * jresult ;
82189   Dali::Toolkit::VideoView result;
82190   {
82191     try {
82192       result = Dali::Toolkit::VideoView::New(swCodec);
82193     } catch (std::out_of_range& e) {
82194       {
82195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82196       };
82197     } catch (std::exception& e) {
82198       {
82199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82200       };
82201     } catch (Dali::DaliException e) {
82202       {
82203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82204       };
82205     } catch (...) {
82206       {
82207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82208       };
82209     }
82210   }
82211
82212   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82213
82214   //argout typemap for const std::string&
82215
82216   return jresult;
82217 }
82218
82219
82220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82221   void * jresult ;
82222   std::string *arg1 = 0 ;
82223   Dali::Toolkit::VideoView result;
82224
82225   if (!jarg1) {
82226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82227     return 0;
82228   }
82229   std::string arg1_str(jarg1);
82230   arg1 = &arg1_str;
82231   {
82232     try {
82233       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
82234     } catch (std::out_of_range& e) {
82235       {
82236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (std::exception& e) {
82239       {
82240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (Dali::DaliException e) {
82243       {
82244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82245       };
82246     } catch (...) {
82247       {
82248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82249       };
82250     }
82251   }
82252
82253   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82254
82255   //argout typemap for const std::string&
82256
82257   return jresult;
82258 }
82259
82260
82261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82262   void * jresult ;
82263   Dali::Toolkit::VideoView *result = 0 ;
82264
82265   {
82266     try {
82267       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82268     } catch (std::out_of_range& e) {
82269       {
82270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82271       };
82272     } catch (std::exception& e) {
82273       {
82274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82275       };
82276     } catch (Dali::DaliException e) {
82277       {
82278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82279       };
82280     } catch (...) {
82281       {
82282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82283       };
82284     }
82285   }
82286
82287   jresult = (void *)result;
82288   return jresult;
82289 }
82290
82291
82292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82293   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82294
82295   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82296   {
82297     try {
82298       delete arg1;
82299     } catch (std::out_of_range& e) {
82300       {
82301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (std::exception& e) {
82304       {
82305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (Dali::DaliException e) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82310       };
82311     } catch (...) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82314       };
82315     }
82316   }
82317
82318 }
82319
82320
82321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82322   void * jresult ;
82323   Dali::Toolkit::VideoView *arg1 = 0 ;
82324   Dali::Toolkit::VideoView *result = 0 ;
82325
82326   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82327   if (!arg1) {
82328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82329     return 0;
82330   }
82331   {
82332     try {
82333       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82334     } catch (std::out_of_range& e) {
82335       {
82336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82337       };
82338     } catch (std::exception& e) {
82339       {
82340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82341       };
82342     } catch (Dali::DaliException e) {
82343       {
82344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82345       };
82346     } catch (...) {
82347       {
82348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82349       };
82350     }
82351   }
82352
82353   jresult = (void *)result;
82354   return jresult;
82355 }
82356
82357
82358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82359   void * jresult ;
82360   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82361   Dali::Toolkit::VideoView *arg2 = 0 ;
82362   Dali::Toolkit::VideoView *result = 0 ;
82363
82364   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82365   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82366   if (!arg2) {
82367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82368     return 0;
82369   }
82370   {
82371     try {
82372       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82373     } catch (std::out_of_range& e) {
82374       {
82375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82376       };
82377     } catch (std::exception& e) {
82378       {
82379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82380       };
82381     } catch (Dali::DaliException e) {
82382       {
82383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82384       };
82385     } catch (...) {
82386       {
82387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82388       };
82389     }
82390   }
82391
82392   jresult = (void *)result;
82393   return jresult;
82394 }
82395
82396
82397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82398   void * jresult ;
82399   Dali::BaseHandle arg1 ;
82400   Dali::BaseHandle *argp1 ;
82401   Dali::Toolkit::VideoView result;
82402
82403   argp1 = (Dali::BaseHandle *)jarg1;
82404   if (!argp1) {
82405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82406     return 0;
82407   }
82408   arg1 = *argp1;
82409   {
82410     try {
82411       result = Dali::Toolkit::VideoView::DownCast(arg1);
82412     } catch (std::out_of_range& e) {
82413       {
82414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (std::exception& e) {
82417       {
82418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82419       };
82420     } catch (Dali::DaliException e) {
82421       {
82422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82423       };
82424     } catch (...) {
82425       {
82426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82427       };
82428     }
82429   }
82430
82431   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82432   return jresult;
82433 }
82434
82435
82436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82437   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82438
82439   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82440   {
82441     try {
82442       (arg1)->Play();
82443     } catch (std::out_of_range& e) {
82444       {
82445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82446       };
82447     } catch (std::exception& e) {
82448       {
82449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82450       };
82451     } catch (Dali::DaliException e) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82454       };
82455     } catch (...) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82458       };
82459     }
82460   }
82461
82462 }
82463
82464
82465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82466   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82467
82468   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82469   {
82470     try {
82471       (arg1)->Pause();
82472     } catch (std::out_of_range& e) {
82473       {
82474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82475       };
82476     } catch (std::exception& e) {
82477       {
82478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82479       };
82480     } catch (Dali::DaliException e) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82483       };
82484     } catch (...) {
82485       {
82486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82487       };
82488     }
82489   }
82490
82491 }
82492
82493
82494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82495   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82496
82497   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82498   {
82499     try {
82500       (arg1)->Stop();
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82508       };
82509     } catch (Dali::DaliException e) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82512       };
82513     } catch (...) {
82514       {
82515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82516       };
82517     }
82518   }
82519
82520 }
82521
82522
82523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82524   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82525   int arg2 ;
82526
82527   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82528   arg2 = (int)jarg2;
82529   {
82530     try {
82531       (arg1)->Forward(arg2);
82532     } catch (std::out_of_range& e) {
82533       {
82534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82535       };
82536     } catch (std::exception& e) {
82537       {
82538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82539       };
82540     } catch (Dali::DaliException e) {
82541       {
82542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82543       };
82544     } catch (...) {
82545       {
82546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82547       };
82548     }
82549   }
82550
82551 }
82552
82553
82554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82555   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82556   int arg2 ;
82557
82558   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82559   arg2 = (int)jarg2;
82560   {
82561     try {
82562       (arg1)->Backward(arg2);
82563     } catch (std::out_of_range& e) {
82564       {
82565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82566       };
82567     } catch (std::exception& e) {
82568       {
82569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82570       };
82571     } catch (Dali::DaliException e) {
82572       {
82573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82574       };
82575     } catch (...) {
82576       {
82577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82578       };
82579     }
82580   }
82581
82582 }
82583
82584
82585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82586   void * jresult ;
82587   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82588   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82589
82590   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82591   {
82592     try {
82593       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82594     } catch (std::out_of_range& e) {
82595       {
82596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82597       };
82598     } catch (std::exception& e) {
82599       {
82600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82601       };
82602     } catch (Dali::DaliException e) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82605       };
82606     } catch (...) {
82607       {
82608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82609       };
82610     }
82611   }
82612
82613   jresult = (void *)result;
82614   return jresult;
82615 }
82616
82617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82618 {
82619   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82620   if( arg1 == nullptr )
82621   {
82622     DALI_LOG_ERROR("VideoView is nullptr!");
82623     return nullptr;
82624   }
82625   void * ret = nullptr;
82626   {
82627     try{
82628
82629       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82630       ret = Dali::AnyCast< void * >( result );
82631
82632     } catch (std::out_of_range& e) {
82633       {
82634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82635       };
82636     } catch (std::exception& e) {
82637       {
82638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82639       };
82640     } catch (Dali::DaliException e) {
82641       {
82642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82643       };
82644     } catch (...) {
82645       {
82646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82647       };
82648     }
82649   }
82650   return ret;
82651 }
82652
82653
82654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82655   int jresult ;
82656   int result;
82657
82658   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82659   jresult = (int)result;
82660   return jresult;
82661 }
82662
82663
82664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82665   int jresult ;
82666   int result;
82667
82668   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82669   jresult = (int)result;
82670   return jresult;
82671 }
82672
82673
82674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82675   int jresult ;
82676   int result;
82677
82678   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82679   jresult = (int)result;
82680   return jresult;
82681 }
82682
82683
82684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82685   int jresult ;
82686   int result;
82687
82688   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82689   jresult = (int)result;
82690   return jresult;
82691 }
82692
82693
82694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82695   int jresult ;
82696   int result;
82697
82698   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82699   jresult = (int)result;
82700   return jresult;
82701 }
82702
82703
82704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82705   int jresult ;
82706   int result;
82707
82708   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82709   jresult = (int)result;
82710   return jresult;
82711 }
82712
82713
82714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82715   int jresult ;
82716   int result;
82717
82718   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82719   jresult = (int)result;
82720   return jresult;
82721 }
82722
82723
82724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82725   int jresult ;
82726   int result;
82727
82728   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82729   jresult = (int)result;
82730   return jresult;
82731 }
82732
82733
82734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82735   int jresult ;
82736   int result;
82737
82738   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82739   jresult = (int)result;
82740   return jresult;
82741 }
82742
82743
82744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82745   int jresult ;
82746   int result;
82747
82748   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82749   jresult = (int)result;
82750   return jresult;
82751 }
82752
82753
82754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82755   int jresult ;
82756   int result;
82757
82758   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82759   jresult = (int)result;
82760   return jresult;
82761 }
82762
82763
82764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82765   int jresult ;
82766   int result;
82767
82768   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82769   jresult = (int)result;
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82775   int jresult ;
82776   int result;
82777
82778   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82779   jresult = (int)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82785   int jresult ;
82786   int result;
82787
82788   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82789   jresult = (int)result;
82790   return jresult;
82791 }
82792
82793
82794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82795   int jresult ;
82796   int result;
82797
82798   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82799   jresult = (int)result;
82800   return jresult;
82801 }
82802
82803
82804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82805   int jresult ;
82806   int result;
82807
82808   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82809   jresult = (int)result;
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82815   int jresult ;
82816   int result;
82817
82818   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82819   jresult = (int)result;
82820   return jresult;
82821 }
82822
82823
82824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82825   int jresult ;
82826   int result;
82827
82828   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82829   jresult = (int)result;
82830   return jresult;
82831 }
82832
82833
82834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82835   int jresult ;
82836   int result;
82837
82838   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82839   jresult = (int)result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82845   int jresult ;
82846   int result;
82847
82848   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82849   jresult = (int)result;
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82855   int jresult ;
82856   int result;
82857
82858   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82859   jresult = (int)result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82865   void * jresult ;
82866   Dali::Toolkit::Popup::Property *result = 0 ;
82867
82868   {
82869     try {
82870       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82871     } catch (std::out_of_range& e) {
82872       {
82873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82874       };
82875     } catch (std::exception& e) {
82876       {
82877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82878       };
82879     } catch (Dali::DaliException e) {
82880       {
82881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82882       };
82883     } catch (...) {
82884       {
82885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82886       };
82887     }
82888   }
82889
82890   jresult = (void *)result;
82891   return jresult;
82892 }
82893
82894
82895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82896   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82897
82898   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82899   {
82900     try {
82901       delete arg1;
82902     } catch (std::out_of_range& e) {
82903       {
82904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82905       };
82906     } catch (std::exception& e) {
82907       {
82908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82909       };
82910     } catch (Dali::DaliException e) {
82911       {
82912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82913       };
82914     } catch (...) {
82915       {
82916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82917       };
82918     }
82919   }
82920
82921 }
82922
82923
82924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82925   void * jresult ;
82926   Dali::Toolkit::Popup *result = 0 ;
82927
82928   {
82929     try {
82930       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82931     } catch (std::out_of_range& e) {
82932       {
82933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82934       };
82935     } catch (std::exception& e) {
82936       {
82937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82938       };
82939     } catch (Dali::DaliException e) {
82940       {
82941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82942       };
82943     } catch (...) {
82944       {
82945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82946       };
82947     }
82948   }
82949
82950   jresult = (void *)result;
82951   return jresult;
82952 }
82953
82954
82955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82956   void * jresult ;
82957   Dali::Toolkit::Popup result;
82958
82959   {
82960     try {
82961       result = Dali::Toolkit::Popup::New();
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::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82982   return jresult;
82983 }
82984
82985
82986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82987   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82988
82989   arg1 = (Dali::Toolkit::Popup *)jarg1;
82990   {
82991     try {
82992       delete arg1;
82993     } catch (std::out_of_range& e) {
82994       {
82995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82996       };
82997     } catch (std::exception& e) {
82998       {
82999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83000       };
83001     } catch (Dali::DaliException e) {
83002       {
83003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83004       };
83005     } catch (...) {
83006       {
83007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83008       };
83009     }
83010   }
83011
83012 }
83013
83014
83015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83016   void * jresult ;
83017   Dali::Toolkit::Popup *arg1 = 0 ;
83018   Dali::Toolkit::Popup *result = 0 ;
83019
83020   arg1 = (Dali::Toolkit::Popup *)jarg1;
83021   if (!arg1) {
83022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83023     return 0;
83024   }
83025   {
83026     try {
83027       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83028     } catch (std::out_of_range& e) {
83029       {
83030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83031       };
83032     } catch (std::exception& e) {
83033       {
83034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83035       };
83036     } catch (Dali::DaliException e) {
83037       {
83038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83039       };
83040     } catch (...) {
83041       {
83042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83043       };
83044     }
83045   }
83046
83047   jresult = (void *)result;
83048   return jresult;
83049 }
83050
83051
83052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83053   void * jresult ;
83054   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83055   Dali::Toolkit::Popup *arg2 = 0 ;
83056   Dali::Toolkit::Popup *result = 0 ;
83057
83058   arg1 = (Dali::Toolkit::Popup *)jarg1;
83059   arg2 = (Dali::Toolkit::Popup *)jarg2;
83060   if (!arg2) {
83061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83062     return 0;
83063   }
83064   {
83065     try {
83066       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83067     } catch (std::out_of_range& e) {
83068       {
83069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83070       };
83071     } catch (std::exception& e) {
83072       {
83073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83074       };
83075     } catch (Dali::DaliException e) {
83076       {
83077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83078       };
83079     } catch (...) {
83080       {
83081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83082       };
83083     }
83084   }
83085
83086   jresult = (void *)result;
83087   return jresult;
83088 }
83089
83090
83091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83092   void * jresult ;
83093   Dali::BaseHandle arg1 ;
83094   Dali::BaseHandle *argp1 ;
83095   Dali::Toolkit::Popup result;
83096
83097   argp1 = (Dali::BaseHandle *)jarg1;
83098   if (!argp1) {
83099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83100     return 0;
83101   }
83102   arg1 = *argp1;
83103   {
83104     try {
83105       result = Dali::Toolkit::Popup::DownCast(arg1);
83106     } catch (std::out_of_range& e) {
83107       {
83108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83109       };
83110     } catch (std::exception& e) {
83111       {
83112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83113       };
83114     } catch (Dali::DaliException e) {
83115       {
83116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83117       };
83118     } catch (...) {
83119       {
83120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83121       };
83122     }
83123   }
83124
83125   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83126   return jresult;
83127 }
83128
83129
83130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83131   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83132   Dali::Actor arg2 ;
83133   Dali::Actor *argp2 ;
83134
83135   arg1 = (Dali::Toolkit::Popup *)jarg1;
83136   argp2 = (Dali::Actor *)jarg2;
83137   if (!argp2) {
83138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83139     return ;
83140   }
83141   arg2 = *argp2;
83142   {
83143     try {
83144       (arg1)->SetTitle(arg2);
83145     } catch (std::out_of_range& e) {
83146       {
83147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83148       };
83149     } catch (std::exception& e) {
83150       {
83151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83152       };
83153     } catch (Dali::DaliException e) {
83154       {
83155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83156       };
83157     } catch (...) {
83158       {
83159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83160       };
83161     }
83162   }
83163
83164 }
83165
83166
83167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83168   void * jresult ;
83169   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83170   Dali::Actor result;
83171
83172   arg1 = (Dali::Toolkit::Popup *)jarg1;
83173   {
83174     try {
83175       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83176     } catch (std::out_of_range& e) {
83177       {
83178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83179       };
83180     } catch (std::exception& e) {
83181       {
83182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83183       };
83184     } catch (Dali::DaliException e) {
83185       {
83186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83187       };
83188     } catch (...) {
83189       {
83190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83191       };
83192     }
83193   }
83194
83195   jresult = new Dali::Actor((const Dali::Actor &)result);
83196   return jresult;
83197 }
83198
83199
83200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83201   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83202   Dali::Actor arg2 ;
83203   Dali::Actor *argp2 ;
83204
83205   arg1 = (Dali::Toolkit::Popup *)jarg1;
83206   argp2 = (Dali::Actor *)jarg2;
83207   if (!argp2) {
83208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83209     return ;
83210   }
83211   arg2 = *argp2;
83212   {
83213     try {
83214       (arg1)->SetContent(arg2);
83215     } catch (std::out_of_range& e) {
83216       {
83217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83218       };
83219     } catch (std::exception& e) {
83220       {
83221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83222       };
83223     } catch (Dali::DaliException e) {
83224       {
83225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83226       };
83227     } catch (...) {
83228       {
83229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83230       };
83231     }
83232   }
83233
83234 }
83235
83236
83237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83238   void * jresult ;
83239   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83240   Dali::Actor result;
83241
83242   arg1 = (Dali::Toolkit::Popup *)jarg1;
83243   {
83244     try {
83245       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83246     } catch (std::out_of_range& e) {
83247       {
83248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83249       };
83250     } catch (std::exception& e) {
83251       {
83252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83253       };
83254     } catch (Dali::DaliException e) {
83255       {
83256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83257       };
83258     } catch (...) {
83259       {
83260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83261       };
83262     }
83263   }
83264
83265   jresult = new Dali::Actor((const Dali::Actor &)result);
83266   return jresult;
83267 }
83268
83269
83270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83271   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83272   Dali::Actor arg2 ;
83273   Dali::Actor *argp2 ;
83274
83275   arg1 = (Dali::Toolkit::Popup *)jarg1;
83276   argp2 = (Dali::Actor *)jarg2;
83277   if (!argp2) {
83278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83279     return ;
83280   }
83281   arg2 = *argp2;
83282   {
83283     try {
83284       (arg1)->SetFooter(arg2);
83285     } catch (std::out_of_range& e) {
83286       {
83287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83288       };
83289     } catch (std::exception& e) {
83290       {
83291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83292       };
83293     } catch (Dali::DaliException e) {
83294       {
83295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83296       };
83297     } catch (...) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83300       };
83301     }
83302   }
83303
83304 }
83305
83306
83307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83308   void * jresult ;
83309   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83310   Dali::Actor result;
83311
83312   arg1 = (Dali::Toolkit::Popup *)jarg1;
83313   {
83314     try {
83315       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83316     } catch (std::out_of_range& e) {
83317       {
83318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83319       };
83320     } catch (std::exception& e) {
83321       {
83322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83323       };
83324     } catch (Dali::DaliException e) {
83325       {
83326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83327       };
83328     } catch (...) {
83329       {
83330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83331       };
83332     }
83333   }
83334
83335   jresult = new Dali::Actor((const Dali::Actor &)result);
83336   return jresult;
83337 }
83338
83339
83340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83341   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83342   Dali::Toolkit::Popup::DisplayState arg2 ;
83343
83344   arg1 = (Dali::Toolkit::Popup *)jarg1;
83345   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83346   {
83347     try {
83348       (arg1)->SetDisplayState(arg2);
83349     } catch (std::out_of_range& e) {
83350       {
83351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83352       };
83353     } catch (std::exception& e) {
83354       {
83355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83356       };
83357     } catch (Dali::DaliException e) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83360       };
83361     } catch (...) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83364       };
83365     }
83366   }
83367
83368 }
83369
83370
83371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83372   int jresult ;
83373   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83374   Dali::Toolkit::Popup::DisplayState result;
83375
83376   arg1 = (Dali::Toolkit::Popup *)jarg1;
83377   {
83378     try {
83379       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83380     } catch (std::out_of_range& e) {
83381       {
83382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83383       };
83384     } catch (std::exception& e) {
83385       {
83386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83387       };
83388     } catch (Dali::DaliException e) {
83389       {
83390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83391       };
83392     } catch (...) {
83393       {
83394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83395       };
83396     }
83397   }
83398
83399   jresult = (int)result;
83400   return jresult;
83401 }
83402
83403
83404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83405   void * jresult ;
83406   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83407   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83408
83409   arg1 = (Dali::Toolkit::Popup *)jarg1;
83410   {
83411     try {
83412       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83413     } catch (std::out_of_range& e) {
83414       {
83415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (std::exception& e) {
83418       {
83419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (Dali::DaliException e) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83424       };
83425     } catch (...) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83428       };
83429     }
83430   }
83431
83432   jresult = (void *)result;
83433   return jresult;
83434 }
83435
83436
83437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83438   void * jresult ;
83439   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83440   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83441
83442   arg1 = (Dali::Toolkit::Popup *)jarg1;
83443   {
83444     try {
83445       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83446     } catch (std::out_of_range& e) {
83447       {
83448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83449       };
83450     } catch (std::exception& e) {
83451       {
83452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (Dali::DaliException e) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83461       };
83462     }
83463   }
83464
83465   jresult = (void *)result;
83466   return jresult;
83467 }
83468
83469
83470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83471   void * jresult ;
83472   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83473   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83474
83475   arg1 = (Dali::Toolkit::Popup *)jarg1;
83476   {
83477     try {
83478       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
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_Popup_HidingSignal(void * jarg1) {
83504   void * jresult ;
83505   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83506   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83507
83508   arg1 = (Dali::Toolkit::Popup *)jarg1;
83509   {
83510     try {
83511       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83512     } catch (std::out_of_range& e) {
83513       {
83514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83515       };
83516     } catch (std::exception& e) {
83517       {
83518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83519       };
83520     } catch (Dali::DaliException e) {
83521       {
83522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83523       };
83524     } catch (...) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83527       };
83528     }
83529   }
83530
83531   jresult = (void *)result;
83532   return jresult;
83533 }
83534
83535
83536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83537   void * jresult ;
83538   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83539   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83540
83541   arg1 = (Dali::Toolkit::Popup *)jarg1;
83542   {
83543     try {
83544       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83545     } catch (std::out_of_range& e) {
83546       {
83547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83548       };
83549     } catch (std::exception& e) {
83550       {
83551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83552       };
83553     } catch (Dali::DaliException e) {
83554       {
83555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83556       };
83557     } catch (...) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83560       };
83561     }
83562   }
83563
83564   jresult = (void *)result;
83565   return jresult;
83566 }
83567
83568
83569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83570   int jresult ;
83571   int result;
83572
83573   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83574   jresult = (int)result;
83575   return jresult;
83576 }
83577
83578
83579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83580   int jresult ;
83581   int result;
83582
83583   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83584   jresult = (int)result;
83585   return jresult;
83586 }
83587
83588
83589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83590   int jresult ;
83591   int result;
83592
83593   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83594   jresult = (int)result;
83595   return jresult;
83596 }
83597
83598
83599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83600   int jresult ;
83601   int result;
83602
83603   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83604   jresult = (int)result;
83605   return jresult;
83606 }
83607
83608
83609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83610   int jresult ;
83611   int result;
83612
83613   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83614   jresult = (int)result;
83615   return jresult;
83616 }
83617
83618
83619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83620   int jresult ;
83621   int result;
83622
83623   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83624   jresult = (int)result;
83625   return jresult;
83626 }
83627
83628
83629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83630   int jresult ;
83631   int result;
83632
83633   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83634   jresult = (int)result;
83635   return jresult;
83636 }
83637
83638
83639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83640   int jresult ;
83641   int result;
83642
83643   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83644   jresult = (int)result;
83645   return jresult;
83646 }
83647
83648
83649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83650   int jresult ;
83651   int result;
83652
83653   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83654   jresult = (int)result;
83655   return jresult;
83656 }
83657
83658
83659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83660   void * jresult ;
83661   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83662
83663   {
83664     try {
83665       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83666     } catch (std::out_of_range& e) {
83667       {
83668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83669       };
83670     } catch (std::exception& e) {
83671       {
83672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83673       };
83674     } catch (Dali::DaliException e) {
83675       {
83676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83677       };
83678     } catch (...) {
83679       {
83680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83681       };
83682     }
83683   }
83684
83685   jresult = (void *)result;
83686   return jresult;
83687 }
83688
83689
83690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83691   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83692
83693   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83694   {
83695     try {
83696       delete arg1;
83697     } catch (std::out_of_range& e) {
83698       {
83699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83700       };
83701     } catch (std::exception& e) {
83702       {
83703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83704       };
83705     } catch (Dali::DaliException e) {
83706       {
83707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83708       };
83709     } catch (...) {
83710       {
83711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83712       };
83713     }
83714   }
83715
83716 }
83717
83718
83719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83720   void * jresult ;
83721   Dali::Toolkit::ProgressBar result;
83722
83723   {
83724     try {
83725       result = Dali::Toolkit::ProgressBar::New();
83726     } catch (std::out_of_range& e) {
83727       {
83728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83729       };
83730     } catch (std::exception& e) {
83731       {
83732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83733       };
83734     } catch (Dali::DaliException e) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83737       };
83738     } catch (...) {
83739       {
83740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83741       };
83742     }
83743   }
83744
83745   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83746   return jresult;
83747 }
83748
83749
83750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83751   void * jresult ;
83752   Dali::Toolkit::ProgressBar *result = 0 ;
83753
83754   {
83755     try {
83756       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83757     } catch (std::out_of_range& e) {
83758       {
83759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83760       };
83761     } catch (std::exception& e) {
83762       {
83763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83764       };
83765     } catch (Dali::DaliException e) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83772       };
83773     }
83774   }
83775
83776   jresult = (void *)result;
83777   return jresult;
83778 }
83779
83780
83781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83782   void * jresult ;
83783   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83784   Dali::Toolkit::ProgressBar *result = 0 ;
83785
83786   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83787   if (!arg1) {
83788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83789     return 0;
83790   }
83791   {
83792     try {
83793       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83794     } catch (std::out_of_range& e) {
83795       {
83796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83797       };
83798     } catch (std::exception& e) {
83799       {
83800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83801       };
83802     } catch (Dali::DaliException e) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83805       };
83806     } catch (...) {
83807       {
83808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83809       };
83810     }
83811   }
83812
83813   jresult = (void *)result;
83814   return jresult;
83815 }
83816
83817
83818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83819   void * jresult ;
83820   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83821   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83822   Dali::Toolkit::ProgressBar *result = 0 ;
83823
83824   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83825   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83826   if (!arg2) {
83827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83828     return 0;
83829   }
83830   {
83831     try {
83832       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83840       };
83841     } catch (Dali::DaliException e) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83844       };
83845     } catch (...) {
83846       {
83847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83848       };
83849     }
83850   }
83851
83852   jresult = (void *)result;
83853   return jresult;
83854 }
83855
83856
83857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83858   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83859
83860   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83861   {
83862     try {
83863       delete arg1;
83864     } catch (std::out_of_range& e) {
83865       {
83866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83867       };
83868     } catch (std::exception& e) {
83869       {
83870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83871       };
83872     } catch (Dali::DaliException e) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83875       };
83876     } catch (...) {
83877       {
83878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83879       };
83880     }
83881   }
83882
83883 }
83884
83885
83886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83887   void * jresult ;
83888   Dali::BaseHandle arg1 ;
83889   Dali::BaseHandle *argp1 ;
83890   Dali::Toolkit::ProgressBar result;
83891
83892   argp1 = (Dali::BaseHandle *)jarg1;
83893   if (!argp1) {
83894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83895     return 0;
83896   }
83897   arg1 = *argp1;
83898   {
83899     try {
83900       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83901     } catch (std::out_of_range& e) {
83902       {
83903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (std::exception& e) {
83906       {
83907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83908       };
83909     } catch (Dali::DaliException e) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83912       };
83913     } catch (...) {
83914       {
83915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83916       };
83917     }
83918   }
83919
83920   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83921   return jresult;
83922 }
83923
83924
83925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83926   void * jresult ;
83927   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83928   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83929
83930   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83931   {
83932     try {
83933       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83934     } catch (std::out_of_range& e) {
83935       {
83936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83937       };
83938     } catch (std::exception& e) {
83939       {
83940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83941       };
83942     } catch (Dali::DaliException e) {
83943       {
83944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83945       };
83946     } catch (...) {
83947       {
83948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83949       };
83950     }
83951   }
83952
83953   jresult = (void *)result;
83954   return jresult;
83955 }
83956
83957
83958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83959   void * jresult ;
83960   Dali::Toolkit::GaussianBlurView *result = 0 ;
83961
83962   {
83963     try {
83964       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83965     } catch (std::out_of_range& e) {
83966       {
83967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83968       };
83969     } catch (std::exception& e) {
83970       {
83971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83972       };
83973     } catch (Dali::DaliException e) {
83974       {
83975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83976       };
83977     } catch (...) {
83978       {
83979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83980       };
83981     }
83982   }
83983
83984   jresult = (void *)result;
83985   return jresult;
83986 }
83987
83988
83989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83990   void * jresult ;
83991   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83992   Dali::Toolkit::GaussianBlurView *result = 0 ;
83993
83994   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83995   if (!arg1) {
83996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83997     return 0;
83998   }
83999   {
84000     try {
84001       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84009       };
84010     } catch (Dali::DaliException e) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84017       };
84018     }
84019   }
84020
84021   jresult = (void *)result;
84022   return jresult;
84023 }
84024
84025
84026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
84027   void * jresult ;
84028   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84029   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
84030   Dali::Toolkit::GaussianBlurView *result = 0 ;
84031
84032   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84033   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
84034   if (!arg2) {
84035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84036     return 0;
84037   }
84038   {
84039     try {
84040       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
84041     } catch (std::out_of_range& e) {
84042       {
84043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84044       };
84045     } catch (std::exception& e) {
84046       {
84047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84048       };
84049     } catch (Dali::DaliException e) {
84050       {
84051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84052       };
84053     } catch (...) {
84054       {
84055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84056       };
84057     }
84058   }
84059
84060   jresult = (void *)result;
84061   return jresult;
84062 }
84063
84064
84065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
84066   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84067
84068   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84069   {
84070     try {
84071       delete arg1;
84072     } catch (std::out_of_range& e) {
84073       {
84074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84075       };
84076     } catch (std::exception& e) {
84077       {
84078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84079       };
84080     } catch (Dali::DaliException e) {
84081       {
84082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84083       };
84084     } catch (...) {
84085       {
84086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84087       };
84088     }
84089   }
84090
84091 }
84092
84093
84094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
84095   void * jresult ;
84096   Dali::BaseHandle arg1 ;
84097   Dali::BaseHandle *argp1 ;
84098   Dali::Toolkit::GaussianBlurView result;
84099
84100   argp1 = (Dali::BaseHandle *)jarg1;
84101   if (!argp1) {
84102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84103     return 0;
84104   }
84105   arg1 = *argp1;
84106   {
84107     try {
84108       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
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 = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84129   return jresult;
84130 }
84131
84132
84133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84134   void * jresult ;
84135   Dali::Toolkit::GaussianBlurView result;
84136
84137   {
84138     try {
84139       result = Dali::Toolkit::GaussianBlurView::New();
84140     } catch (std::out_of_range& e) {
84141       {
84142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84143       };
84144     } catch (std::exception& e) {
84145       {
84146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84147       };
84148     } catch (Dali::DaliException e) {
84149       {
84150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84151       };
84152     } catch (...) {
84153       {
84154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84155       };
84156     }
84157   }
84158
84159   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84160   return jresult;
84161 }
84162
84163
84164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84165   void * jresult ;
84166   unsigned int arg1 ;
84167   float arg2 ;
84168   Dali::Pixel::Format arg3 ;
84169   float arg4 ;
84170   float arg5 ;
84171   bool arg6 ;
84172   Dali::Toolkit::GaussianBlurView result;
84173
84174   arg1 = (unsigned int)jarg1;
84175   arg2 = (float)jarg2;
84176   arg3 = (Dali::Pixel::Format)jarg3;
84177   arg4 = (float)jarg4;
84178   arg5 = (float)jarg5;
84179   arg6 = jarg6 ? true : false;
84180   {
84181     try {
84182       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (Dali::DaliException e) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84194       };
84195     } catch (...) {
84196       {
84197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84198       };
84199     }
84200   }
84201
84202   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84203   return jresult;
84204 }
84205
84206
84207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84208   void * jresult ;
84209   unsigned int arg1 ;
84210   float arg2 ;
84211   Dali::Pixel::Format arg3 ;
84212   float arg4 ;
84213   float arg5 ;
84214   Dali::Toolkit::GaussianBlurView result;
84215
84216   arg1 = (unsigned int)jarg1;
84217   arg2 = (float)jarg2;
84218   arg3 = (Dali::Pixel::Format)jarg3;
84219   arg4 = (float)jarg4;
84220   arg5 = (float)jarg5;
84221   {
84222     try {
84223       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84224     } catch (std::out_of_range& e) {
84225       {
84226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84227       };
84228     } catch (std::exception& e) {
84229       {
84230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84231       };
84232     } catch (Dali::DaliException e) {
84233       {
84234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84235       };
84236     } catch (...) {
84237       {
84238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84239       };
84240     }
84241   }
84242
84243   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84244   return jresult;
84245 }
84246
84247
84248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84249   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84250   Dali::Actor arg2 ;
84251   Dali::Actor *argp2 ;
84252
84253   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84254   argp2 = (Dali::Actor *)jarg2;
84255   if (!argp2) {
84256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84257     return ;
84258   }
84259   arg2 = *argp2;
84260   {
84261     try {
84262       (arg1)->Add(arg2);
84263     } catch (std::out_of_range& e) {
84264       {
84265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84266       };
84267     } catch (std::exception& e) {
84268       {
84269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (Dali::DaliException e) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84274       };
84275     } catch (...) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84278       };
84279     }
84280   }
84281
84282 }
84283
84284
84285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84286   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84287   Dali::Actor arg2 ;
84288   Dali::Actor *argp2 ;
84289
84290   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84291   argp2 = (Dali::Actor *)jarg2;
84292   if (!argp2) {
84293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84294     return ;
84295   }
84296   arg2 = *argp2;
84297   {
84298     try {
84299       (arg1)->Remove(arg2);
84300     } catch (std::out_of_range& e) {
84301       {
84302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84303       };
84304     } catch (std::exception& e) {
84305       {
84306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84307       };
84308     } catch (Dali::DaliException e) {
84309       {
84310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84311       };
84312     } catch (...) {
84313       {
84314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84315       };
84316     }
84317   }
84318
84319 }
84320
84321
84322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84323   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84324
84325   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84326   {
84327     try {
84328       (arg1)->Activate();
84329     } catch (std::out_of_range& e) {
84330       {
84331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84332       };
84333     } catch (std::exception& e) {
84334       {
84335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84336       };
84337     } catch (Dali::DaliException e) {
84338       {
84339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84340       };
84341     } catch (...) {
84342       {
84343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84344       };
84345     }
84346   }
84347
84348 }
84349
84350
84351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84352   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84353
84354   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84355   {
84356     try {
84357       (arg1)->ActivateOnce();
84358     } catch (std::out_of_range& e) {
84359       {
84360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84361       };
84362     } catch (std::exception& e) {
84363       {
84364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84365       };
84366     } catch (Dali::DaliException e) {
84367       {
84368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84369       };
84370     } catch (...) {
84371       {
84372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84373       };
84374     }
84375   }
84376
84377 }
84378
84379
84380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84381   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84382
84383   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84384   {
84385     try {
84386       (arg1)->Deactivate();
84387     } catch (std::out_of_range& e) {
84388       {
84389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84390       };
84391     } catch (std::exception& e) {
84392       {
84393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84394       };
84395     } catch (Dali::DaliException e) {
84396       {
84397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84398       };
84399     } catch (...) {
84400       {
84401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84402       };
84403     }
84404   }
84405
84406 }
84407
84408
84409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84410   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84411   Dali::Texture arg2 ;
84412   Dali::FrameBuffer arg3 ;
84413   Dali::Texture *argp2 ;
84414   Dali::FrameBuffer *argp3 ;
84415
84416   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84417   argp2 = (Dali::Texture *)jarg2;
84418   if (!argp2) {
84419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84420     return ;
84421   }
84422   arg2 = *argp2;
84423   argp3 = (Dali::FrameBuffer *)jarg3;
84424   if (!argp3) {
84425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84426     return ;
84427   }
84428   arg3 = *argp3;
84429   {
84430     try {
84431       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
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 int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84455   int jresult ;
84456   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84457   Dali::Property::Index result;
84458
84459   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84460   {
84461     try {
84462       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84463     } catch (std::out_of_range& e) {
84464       {
84465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84466       };
84467     } catch (std::exception& e) {
84468       {
84469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84470       };
84471     } catch (Dali::DaliException e) {
84472       {
84473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84474       };
84475     } catch (...) {
84476       {
84477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84478       };
84479     }
84480   }
84481
84482   jresult = result;
84483   return jresult;
84484 }
84485
84486
84487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84488   void * jresult ;
84489   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84490   Dali::FrameBuffer result;
84491
84492   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84493   {
84494     try {
84495       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84496     } catch (std::out_of_range& e) {
84497       {
84498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84499       };
84500     } catch (std::exception& e) {
84501       {
84502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84503       };
84504     } catch (Dali::DaliException e) {
84505       {
84506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84507       };
84508     } catch (...) {
84509       {
84510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84511       };
84512     }
84513   }
84514
84515   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84516   return jresult;
84517 }
84518
84519
84520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84521   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84522   Dali::Vector4 *arg2 = 0 ;
84523
84524   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84525   arg2 = (Dali::Vector4 *)jarg2;
84526   if (!arg2) {
84527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84528     return ;
84529   }
84530   {
84531     try {
84532       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84533     } catch (std::out_of_range& e) {
84534       {
84535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84536       };
84537     } catch (std::exception& e) {
84538       {
84539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84540       };
84541     } catch (Dali::DaliException e) {
84542       {
84543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84544       };
84545     } catch (...) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84548       };
84549     }
84550   }
84551
84552 }
84553
84554
84555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84556   void * jresult ;
84557   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84558   Dali::Vector4 result;
84559
84560   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84561   {
84562     try {
84563       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84564     } catch (std::out_of_range& e) {
84565       {
84566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (std::exception& e) {
84569       {
84570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84571       };
84572     } catch (Dali::DaliException e) {
84573       {
84574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84575       };
84576     } catch (...) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84579       };
84580     }
84581   }
84582
84583   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84584   return jresult;
84585 }
84586
84587
84588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84589   void * jresult ;
84590   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84591   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84592
84593   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84594   {
84595     try {
84596       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84604       };
84605     } catch (Dali::DaliException e) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84612       };
84613     }
84614   }
84615
84616   jresult = (void *)result;
84617   return jresult;
84618 }
84619
84620
84621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84622   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84623
84624   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84625   {
84626     try {
84627       delete arg1;
84628     } catch (std::out_of_range& e) {
84629       {
84630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84631       };
84632     } catch (std::exception& e) {
84633       {
84634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84635       };
84636     } catch (Dali::DaliException e) {
84637       {
84638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84639       };
84640     } catch (...) {
84641       {
84642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84643       };
84644     }
84645   }
84646
84647 }
84648
84649
84650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84651   unsigned int jresult ;
84652   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84653   unsigned int result;
84654
84655   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84656   {
84657     try {
84658       result = (unsigned int)(arg1)->GetNumberOfPages();
84659     } catch (std::out_of_range& e) {
84660       {
84661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84662       };
84663     } catch (std::exception& e) {
84664       {
84665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (Dali::DaliException e) {
84668       {
84669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84670       };
84671     } catch (...) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84674       };
84675     }
84676   }
84677
84678   jresult = result;
84679   return jresult;
84680 }
84681
84682
84683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84684   void * jresult ;
84685   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84686   unsigned int arg2 ;
84687   Dali::Texture result;
84688
84689   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84690   arg2 = (unsigned int)jarg2;
84691   {
84692     try {
84693       result = (arg1)->NewPage(arg2);
84694     } catch (std::out_of_range& e) {
84695       {
84696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84697       };
84698     } catch (std::exception& e) {
84699       {
84700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84701       };
84702     } catch (Dali::DaliException e) {
84703       {
84704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84705       };
84706     } catch (...) {
84707       {
84708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84709       };
84710     }
84711   }
84712
84713   jresult = new Dali::Texture((const Dali::Texture &)result);
84714   return jresult;
84715 }
84716
84717
84718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84719   int jresult ;
84720   int result;
84721
84722   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84723   jresult = (int)result;
84724   return jresult;
84725 }
84726
84727
84728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84729   int jresult ;
84730   int result;
84731
84732   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84733   jresult = (int)result;
84734   return jresult;
84735 }
84736
84737
84738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84739   int jresult ;
84740   int result;
84741
84742   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84743   jresult = (int)result;
84744   return jresult;
84745 }
84746
84747
84748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84749   void * jresult ;
84750   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84751
84752   {
84753     try {
84754       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84755     } catch (std::out_of_range& e) {
84756       {
84757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (std::exception& e) {
84760       {
84761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84762       };
84763     } catch (Dali::DaliException e) {
84764       {
84765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84766       };
84767     } catch (...) {
84768       {
84769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84770       };
84771     }
84772   }
84773
84774   jresult = (void *)result;
84775   return jresult;
84776 }
84777
84778
84779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84780   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84781
84782   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84783   {
84784     try {
84785       delete arg1;
84786     } catch (std::out_of_range& e) {
84787       {
84788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84789       };
84790     } catch (std::exception& e) {
84791       {
84792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84793       };
84794     } catch (Dali::DaliException e) {
84795       {
84796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84797       };
84798     } catch (...) {
84799       {
84800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84801       };
84802     }
84803   }
84804
84805 }
84806
84807
84808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84809   void * jresult ;
84810   Dali::Toolkit::PageTurnView *result = 0 ;
84811
84812   {
84813     try {
84814       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84815     } catch (std::out_of_range& e) {
84816       {
84817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (std::exception& e) {
84820       {
84821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84822       };
84823     } catch (Dali::DaliException e) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84826       };
84827     } catch (...) {
84828       {
84829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84830       };
84831     }
84832   }
84833
84834   jresult = (void *)result;
84835   return jresult;
84836 }
84837
84838
84839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84840   void * jresult ;
84841   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84842   Dali::Toolkit::PageTurnView *result = 0 ;
84843
84844   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84845   if (!arg1) {
84846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84847     return 0;
84848   }
84849   {
84850     try {
84851       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84852     } catch (std::out_of_range& e) {
84853       {
84854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84855       };
84856     } catch (std::exception& e) {
84857       {
84858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (Dali::DaliException e) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84863       };
84864     } catch (...) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84867       };
84868     }
84869   }
84870
84871   jresult = (void *)result;
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84877   void * jresult ;
84878   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84879   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84880   Dali::Toolkit::PageTurnView *result = 0 ;
84881
84882   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84883   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84884   if (!arg2) {
84885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84886     return 0;
84887   }
84888   {
84889     try {
84890       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84891     } catch (std::out_of_range& e) {
84892       {
84893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (std::exception& e) {
84896       {
84897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84898       };
84899     } catch (Dali::DaliException e) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84902       };
84903     } catch (...) {
84904       {
84905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84906       };
84907     }
84908   }
84909
84910   jresult = (void *)result;
84911   return jresult;
84912 }
84913
84914
84915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84916   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84917
84918   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84919   {
84920     try {
84921       delete arg1;
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84929       };
84930     } catch (Dali::DaliException e) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84933       };
84934     } catch (...) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84937       };
84938     }
84939   }
84940
84941 }
84942
84943
84944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84945   void * jresult ;
84946   Dali::BaseHandle arg1 ;
84947   Dali::BaseHandle *argp1 ;
84948   Dali::Toolkit::PageTurnView result;
84949
84950   argp1 = (Dali::BaseHandle *)jarg1;
84951   if (!argp1) {
84952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84953     return 0;
84954   }
84955   arg1 = *argp1;
84956   {
84957     try {
84958       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84959     } catch (std::out_of_range& e) {
84960       {
84961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (std::exception& e) {
84964       {
84965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (Dali::DaliException e) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84970       };
84971     } catch (...) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84974       };
84975     }
84976   }
84977
84978   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84979   return jresult;
84980 }
84981
84982
84983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84984   void * jresult ;
84985   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84986   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84987
84988   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84989   {
84990     try {
84991       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84992     } catch (std::out_of_range& e) {
84993       {
84994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (std::exception& e) {
84997       {
84998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84999       };
85000     } catch (Dali::DaliException e) {
85001       {
85002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85003       };
85004     } catch (...) {
85005       {
85006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85007       };
85008     }
85009   }
85010
85011   jresult = (void *)result;
85012   return jresult;
85013 }
85014
85015
85016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
85017   void * jresult ;
85018   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85019   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85020
85021   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85022   {
85023     try {
85024       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
85025     } catch (std::out_of_range& e) {
85026       {
85027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85028       };
85029     } catch (std::exception& e) {
85030       {
85031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85032       };
85033     } catch (Dali::DaliException e) {
85034       {
85035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85036       };
85037     } catch (...) {
85038       {
85039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85040       };
85041     }
85042   }
85043
85044   jresult = (void *)result;
85045   return jresult;
85046 }
85047
85048
85049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
85050   void * jresult ;
85051   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85052   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85053
85054   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85055   {
85056     try {
85057       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
85058     } catch (std::out_of_range& e) {
85059       {
85060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85061       };
85062     } catch (std::exception& e) {
85063       {
85064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85065       };
85066     } catch (Dali::DaliException e) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85069       };
85070     } catch (...) {
85071       {
85072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85073       };
85074     }
85075   }
85076
85077   jresult = (void *)result;
85078   return jresult;
85079 }
85080
85081
85082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
85083   void * jresult ;
85084   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85085   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85086
85087   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85088   {
85089     try {
85090       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
85091     } catch (std::out_of_range& e) {
85092       {
85093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (std::exception& e) {
85096       {
85097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (Dali::DaliException e) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85102       };
85103     } catch (...) {
85104       {
85105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85106       };
85107     }
85108   }
85109
85110   jresult = (void *)result;
85111   return jresult;
85112 }
85113
85114
85115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
85116   void * jresult ;
85117   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85118
85119   {
85120     try {
85121       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
85122     } catch (std::out_of_range& e) {
85123       {
85124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (std::exception& e) {
85127       {
85128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85129       };
85130     } catch (Dali::DaliException e) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85133       };
85134     } catch (...) {
85135       {
85136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85137       };
85138     }
85139   }
85140
85141   jresult = (void *)result;
85142   return jresult;
85143 }
85144
85145
85146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
85147   void * jresult ;
85148   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
85149   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85150
85151   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85152   if (!arg1) {
85153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85154     return 0;
85155   }
85156   {
85157     try {
85158       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
85159     } catch (std::out_of_range& e) {
85160       {
85161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85162       };
85163     } catch (std::exception& e) {
85164       {
85165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85166       };
85167     } catch (Dali::DaliException e) {
85168       {
85169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85170       };
85171     } catch (...) {
85172       {
85173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85174       };
85175     }
85176   }
85177
85178   jresult = (void *)result;
85179   return jresult;
85180 }
85181
85182
85183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85184   void * jresult ;
85185   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85186   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85187   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85188
85189   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85190   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85191   if (!arg2) {
85192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85193     return 0;
85194   }
85195   {
85196     try {
85197       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85198     } catch (std::out_of_range& e) {
85199       {
85200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (std::exception& e) {
85203       {
85204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (Dali::DaliException e) {
85207       {
85208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85209       };
85210     } catch (...) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85213       };
85214     }
85215   }
85216
85217   jresult = (void *)result;
85218   return jresult;
85219 }
85220
85221
85222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85223   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85224
85225   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85226   {
85227     try {
85228       delete arg1;
85229     } catch (std::out_of_range& e) {
85230       {
85231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85232       };
85233     } catch (std::exception& e) {
85234       {
85235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85236       };
85237     } catch (Dali::DaliException e) {
85238       {
85239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85240       };
85241     } catch (...) {
85242       {
85243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85244       };
85245     }
85246   }
85247
85248 }
85249
85250
85251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85252   void * jresult ;
85253   Dali::Toolkit::PageFactory *arg1 = 0 ;
85254   Dali::Vector2 *arg2 = 0 ;
85255   Dali::Toolkit::PageTurnLandscapeView result;
85256
85257   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85258   if (!arg1) {
85259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85260     return 0;
85261   }
85262   arg2 = (Dali::Vector2 *)jarg2;
85263   if (!arg2) {
85264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85265     return 0;
85266   }
85267   {
85268     try {
85269       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85270     } catch (std::out_of_range& e) {
85271       {
85272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (std::exception& e) {
85275       {
85276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85277       };
85278     } catch (Dali::DaliException e) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85281       };
85282     } catch (...) {
85283       {
85284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85285       };
85286     }
85287   }
85288
85289   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85290   return jresult;
85291 }
85292
85293
85294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85295   void * jresult ;
85296   Dali::BaseHandle arg1 ;
85297   Dali::BaseHandle *argp1 ;
85298   Dali::Toolkit::PageTurnLandscapeView result;
85299
85300   argp1 = (Dali::BaseHandle *)jarg1;
85301   if (!argp1) {
85302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85303     return 0;
85304   }
85305   arg1 = *argp1;
85306   {
85307     try {
85308       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85309     } catch (std::out_of_range& e) {
85310       {
85311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85312       };
85313     } catch (std::exception& e) {
85314       {
85315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85316       };
85317     } catch (Dali::DaliException e) {
85318       {
85319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85320       };
85321     } catch (...) {
85322       {
85323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85324       };
85325     }
85326   }
85327
85328   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85329   return jresult;
85330 }
85331
85332
85333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85334   void * jresult ;
85335   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85336
85337   {
85338     try {
85339       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85340     } catch (std::out_of_range& e) {
85341       {
85342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85343       };
85344     } catch (std::exception& e) {
85345       {
85346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85347       };
85348     } catch (Dali::DaliException e) {
85349       {
85350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85351       };
85352     } catch (...) {
85353       {
85354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85355       };
85356     }
85357   }
85358
85359   jresult = (void *)result;
85360   return jresult;
85361 }
85362
85363
85364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85365   void * jresult ;
85366   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85367   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85368
85369   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85370   if (!arg1) {
85371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85372     return 0;
85373   }
85374   {
85375     try {
85376       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85377     } catch (std::out_of_range& e) {
85378       {
85379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85380       };
85381     } catch (std::exception& e) {
85382       {
85383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (Dali::DaliException e) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85392       };
85393     }
85394   }
85395
85396   jresult = (void *)result;
85397   return jresult;
85398 }
85399
85400
85401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85402   void * jresult ;
85403   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85404   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85405   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85406
85407   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85408   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85409   if (!arg2) {
85410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85411     return 0;
85412   }
85413   {
85414     try {
85415       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85416     } catch (std::out_of_range& e) {
85417       {
85418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85419       };
85420     } catch (std::exception& e) {
85421       {
85422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85423       };
85424     } catch (Dali::DaliException e) {
85425       {
85426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85427       };
85428     } catch (...) {
85429       {
85430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85431       };
85432     }
85433   }
85434
85435   jresult = (void *)result;
85436   return jresult;
85437 }
85438
85439
85440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85441   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85442
85443   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85444   {
85445     try {
85446       delete arg1;
85447     } catch (std::out_of_range& e) {
85448       {
85449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85450       };
85451     } catch (std::exception& e) {
85452       {
85453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85454       };
85455     } catch (Dali::DaliException e) {
85456       {
85457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85458       };
85459     } catch (...) {
85460       {
85461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85462       };
85463     }
85464   }
85465
85466 }
85467
85468
85469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85470   void * jresult ;
85471   Dali::Toolkit::PageFactory *arg1 = 0 ;
85472   Dali::Vector2 *arg2 = 0 ;
85473   Dali::Toolkit::PageTurnPortraitView result;
85474
85475   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85476   if (!arg1) {
85477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85478     return 0;
85479   }
85480   arg2 = (Dali::Vector2 *)jarg2;
85481   if (!arg2) {
85482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85483     return 0;
85484   }
85485   {
85486     try {
85487       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85488     } catch (std::out_of_range& e) {
85489       {
85490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85491       };
85492     } catch (std::exception& e) {
85493       {
85494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85495       };
85496     } catch (Dali::DaliException e) {
85497       {
85498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85499       };
85500     } catch (...) {
85501       {
85502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85503       };
85504     }
85505   }
85506
85507   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85508   return jresult;
85509 }
85510
85511
85512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85513   void * jresult ;
85514   Dali::BaseHandle arg1 ;
85515   Dali::BaseHandle *argp1 ;
85516   Dali::Toolkit::PageTurnPortraitView result;
85517
85518   argp1 = (Dali::BaseHandle *)jarg1;
85519   if (!argp1) {
85520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85521     return 0;
85522   }
85523   arg1 = *argp1;
85524   {
85525     try {
85526       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85527     } catch (std::out_of_range& e) {
85528       {
85529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (std::exception& e) {
85532       {
85533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (Dali::DaliException e) {
85536       {
85537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85538       };
85539     } catch (...) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85542       };
85543     }
85544   }
85545
85546   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85552   int jresult ;
85553   int result;
85554
85555   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85556   jresult = (int)result;
85557   return jresult;
85558 }
85559
85560
85561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85562   int jresult ;
85563   int result;
85564
85565   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85566   jresult = (int)result;
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85572   int jresult ;
85573   int result;
85574
85575   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85576   jresult = (int)result;
85577   return jresult;
85578 }
85579
85580
85581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85582   void * jresult ;
85583   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85584
85585   {
85586     try {
85587       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85588     } catch (std::out_of_range& e) {
85589       {
85590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (std::exception& e) {
85593       {
85594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85595       };
85596     } catch (Dali::DaliException e) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85599       };
85600     } catch (...) {
85601       {
85602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85603       };
85604     }
85605   }
85606
85607   jresult = (void *)result;
85608   return jresult;
85609 }
85610
85611
85612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85613   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85614
85615   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85616   {
85617     try {
85618       delete arg1;
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85626       };
85627     } catch (Dali::DaliException e) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85634       };
85635     }
85636   }
85637
85638 }
85639
85640
85641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85642   void * jresult ;
85643   Dali::Toolkit::ToggleButton *result = 0 ;
85644
85645   {
85646     try {
85647       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85648     } catch (std::out_of_range& e) {
85649       {
85650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85651       };
85652     } catch (std::exception& e) {
85653       {
85654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (Dali::DaliException e) {
85657       {
85658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85659       };
85660     } catch (...) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85663       };
85664     }
85665   }
85666
85667   jresult = (void *)result;
85668   return jresult;
85669 }
85670
85671
85672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85673   void * jresult ;
85674   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85675   Dali::Toolkit::ToggleButton *result = 0 ;
85676
85677   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85678   if (!arg1) {
85679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85680     return 0;
85681   }
85682   {
85683     try {
85684       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85685     } catch (std::out_of_range& e) {
85686       {
85687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85688       };
85689     } catch (std::exception& e) {
85690       {
85691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85692       };
85693     } catch (Dali::DaliException e) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85696       };
85697     } catch (...) {
85698       {
85699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85700       };
85701     }
85702   }
85703
85704   jresult = (void *)result;
85705   return jresult;
85706 }
85707
85708
85709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85710   void * jresult ;
85711   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85712   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85713   Dali::Toolkit::ToggleButton *result = 0 ;
85714
85715   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85716   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85717   if (!arg2) {
85718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85719     return 0;
85720   }
85721   {
85722     try {
85723       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85724     } catch (std::out_of_range& e) {
85725       {
85726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85727       };
85728     } catch (std::exception& e) {
85729       {
85730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85731       };
85732     } catch (Dali::DaliException e) {
85733       {
85734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85735       };
85736     } catch (...) {
85737       {
85738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85739       };
85740     }
85741   }
85742
85743   jresult = (void *)result;
85744   return jresult;
85745 }
85746
85747
85748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85749   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85750
85751   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85752   {
85753     try {
85754       delete arg1;
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85770       };
85771     }
85772   }
85773
85774 }
85775
85776
85777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85778   void * jresult ;
85779   Dali::Toolkit::ToggleButton result;
85780
85781   {
85782     try {
85783       result = Dali::Toolkit::ToggleButton::New();
85784     } catch (std::out_of_range& e) {
85785       {
85786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85787       };
85788     } catch (std::exception& e) {
85789       {
85790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (Dali::DaliException e) {
85793       {
85794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802
85803   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85804   return jresult;
85805 }
85806
85807
85808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85809   void * jresult ;
85810   Dali::BaseHandle arg1 ;
85811   Dali::BaseHandle *argp1 ;
85812   Dali::Toolkit::ToggleButton result;
85813
85814   argp1 = (Dali::BaseHandle *)jarg1;
85815   if (!argp1) {
85816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85817     return 0;
85818   }
85819   arg1 = *argp1;
85820   {
85821     try {
85822       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85823     } catch (std::out_of_range& e) {
85824       {
85825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85826       };
85827     } catch (std::exception& e) {
85828       {
85829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85830       };
85831     } catch (Dali::DaliException e) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85834       };
85835     } catch (...) {
85836       {
85837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85838       };
85839     }
85840   }
85841
85842   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85843   return jresult;
85844 }
85845
85846
85847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85848   void * jresult ;
85849   Dali::Toolkit::Visual::Base *result = 0 ;
85850
85851   {
85852     try {
85853       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85854     } catch (std::out_of_range& e) {
85855       {
85856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (std::exception& e) {
85859       {
85860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85861       };
85862     } catch (Dali::DaliException e) {
85863       {
85864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85865       };
85866     } catch (...) {
85867       {
85868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85869       };
85870     }
85871   }
85872
85873   jresult = (void *)result;
85874   return jresult;
85875 }
85876
85877
85878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85879   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85880
85881   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85882   {
85883     try {
85884       delete arg1;
85885     } catch (std::out_of_range& e) {
85886       {
85887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85888       };
85889     } catch (std::exception& e) {
85890       {
85891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85892       };
85893     } catch (Dali::DaliException e) {
85894       {
85895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85896       };
85897     } catch (...) {
85898       {
85899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85900       };
85901     }
85902   }
85903
85904 }
85905
85906
85907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85908   void * jresult ;
85909   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85910   Dali::Toolkit::Visual::Base *result = 0 ;
85911
85912   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85913   if (!arg1) {
85914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85915     return 0;
85916   }
85917   {
85918     try {
85919       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85920     } catch (std::out_of_range& e) {
85921       {
85922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (std::exception& e) {
85925       {
85926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85927       };
85928     } catch (Dali::DaliException e) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85931       };
85932     } catch (...) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85935       };
85936     }
85937   }
85938
85939   jresult = (void *)result;
85940   return jresult;
85941 }
85942
85943
85944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85945   void * jresult ;
85946   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85947   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85948   Dali::Toolkit::Visual::Base *result = 0 ;
85949
85950   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85951   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85952   if (!arg2) {
85953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85954     return 0;
85955   }
85956   {
85957     try {
85958       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85959     } catch (std::out_of_range& e) {
85960       {
85961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (std::exception& e) {
85964       {
85965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85966       };
85967     } catch (Dali::DaliException e) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85970       };
85971     } catch (...) {
85972       {
85973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85974       };
85975     }
85976   }
85977
85978   jresult = (void *)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85984   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85985   std::string *arg2 = 0 ;
85986
85987   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85988   if (!jarg2) {
85989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85990     return ;
85991   }
85992   std::string arg2_str(jarg2);
85993   arg2 = &arg2_str;
85994   {
85995     try {
85996       (arg1)->SetName((std::string const &)*arg2);
85997     } catch (std::out_of_range& e) {
85998       {
85999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86000       };
86001     } catch (std::exception& e) {
86002       {
86003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86004       };
86005     } catch (Dali::DaliException e) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86008       };
86009     } catch (...) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86012       };
86013     }
86014   }
86015
86016
86017   //argout typemap for const std::string&
86018
86019 }
86020
86021
86022 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
86023   char * jresult ;
86024   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86025   std::string *result = 0 ;
86026
86027   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86028   {
86029     try {
86030       result = (std::string *) &(arg1)->GetName();
86031     } catch (std::out_of_range& e) {
86032       {
86033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (std::exception& e) {
86036       {
86037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86038       };
86039     } catch (Dali::DaliException e) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86042       };
86043     } catch (...) {
86044       {
86045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86046       };
86047     }
86048   }
86049
86050   jresult = SWIG_csharp_string_callback(result->c_str());
86051   return jresult;
86052 }
86053
86054
86055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
86056   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86057   Dali::Property::Map *arg2 = 0 ;
86058   Dali::Size arg3 ;
86059   Dali::Size *argp3 ;
86060
86061   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86062   arg2 = (Dali::Property::Map *)jarg2;
86063   if (!arg2) {
86064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86065     return ;
86066   }
86067   argp3 = (Dali::Size *)jarg3;
86068   if (!argp3) {
86069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
86070     return ;
86071   }
86072   arg3 = *argp3;
86073   {
86074     try {
86075       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
86076     } catch (std::out_of_range& e) {
86077       {
86078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86079       };
86080     } catch (std::exception& e) {
86081       {
86082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86083       };
86084     } catch (Dali::DaliException e) {
86085       {
86086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86087       };
86088     } catch (...) {
86089       {
86090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86091       };
86092     }
86093   }
86094
86095 }
86096
86097
86098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
86099   float jresult ;
86100   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86101   float arg2 ;
86102   float result;
86103
86104   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86105   arg2 = (float)jarg2;
86106   {
86107     try {
86108       result = (float)(arg1)->GetHeightForWidth(arg2);
86109     } catch (std::out_of_range& e) {
86110       {
86111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86112       };
86113     } catch (std::exception& e) {
86114       {
86115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86116       };
86117     } catch (Dali::DaliException e) {
86118       {
86119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86120       };
86121     } catch (...) {
86122       {
86123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86124       };
86125     }
86126   }
86127
86128   jresult = result;
86129   return jresult;
86130 }
86131
86132
86133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
86134   float jresult ;
86135   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86136   float arg2 ;
86137   float result;
86138
86139   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86140   arg2 = (float)jarg2;
86141   {
86142     try {
86143       result = (float)(arg1)->GetWidthForHeight(arg2);
86144     } catch (std::out_of_range& e) {
86145       {
86146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86147       };
86148     } catch (std::exception& e) {
86149       {
86150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86151       };
86152     } catch (Dali::DaliException e) {
86153       {
86154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86155       };
86156     } catch (...) {
86157       {
86158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86159       };
86160     }
86161   }
86162
86163   jresult = result;
86164   return jresult;
86165 }
86166
86167
86168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
86169   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86170   Dali::Vector2 *arg2 = 0 ;
86171
86172   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86173   arg2 = (Dali::Vector2 *)jarg2;
86174   if (!arg2) {
86175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
86176     return ;
86177   }
86178   {
86179     try {
86180       (arg1)->GetNaturalSize(*arg2);
86181     } catch (std::out_of_range& e) {
86182       {
86183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86184       };
86185     } catch (std::exception& e) {
86186       {
86187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86188       };
86189     } catch (Dali::DaliException e) {
86190       {
86191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86192       };
86193     } catch (...) {
86194       {
86195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86196       };
86197     }
86198   }
86199
86200 }
86201
86202
86203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86204   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86205   float arg2 ;
86206
86207   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86208   arg2 = (int)jarg2;
86209   {
86210     try {
86211       (arg1)->SetDepthIndex(arg2);
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86219       };
86220     } catch (Dali::DaliException e) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86223       };
86224     } catch (...) {
86225       {
86226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86227       };
86228     }
86229   }
86230
86231 }
86232
86233
86234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86235   int jresult ;
86236   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86237   int result;
86238
86239   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86240   {
86241     try {
86242       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86243     } catch (std::out_of_range& e) {
86244       {
86245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86246       };
86247     } catch (std::exception& e) {
86248       {
86249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86250       };
86251     } catch (Dali::DaliException e) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86254       };
86255     } catch (...) {
86256       {
86257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86258       };
86259     }
86260   }
86261
86262   jresult = result;
86263   return jresult;
86264 }
86265
86266
86267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86268   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86269   Dali::Property::Map *arg2 = 0 ;
86270
86271   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86272   arg2 = (Dali::Property::Map *)jarg2;
86273   if (!arg2) {
86274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86275     return ;
86276   }
86277   {
86278     try {
86279       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86280     } catch (std::out_of_range& e) {
86281       {
86282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86283       };
86284     } catch (std::exception& e) {
86285       {
86286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86287       };
86288     } catch (Dali::DaliException e) {
86289       {
86290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86291       };
86292     } catch (...) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86295       };
86296     }
86297   }
86298
86299 }
86300
86301
86302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86303   void * jresult ;
86304   Dali::Toolkit::VisualFactory result;
86305
86306   {
86307     try {
86308       result = Dali::Toolkit::VisualFactory::Get();
86309     } catch (std::out_of_range& e) {
86310       {
86311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (std::exception& e) {
86314       {
86315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86316       };
86317     } catch (Dali::DaliException e) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86320       };
86321     } catch (...) {
86322       {
86323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86324       };
86325     }
86326   }
86327
86328   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86329   return jresult;
86330 }
86331
86332
86333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86334   void * jresult ;
86335   Dali::Toolkit::VisualFactory *result = 0 ;
86336
86337   {
86338     try {
86339       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86340     } catch (std::out_of_range& e) {
86341       {
86342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86343       };
86344     } catch (std::exception& e) {
86345       {
86346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86347       };
86348     } catch (Dali::DaliException e) {
86349       {
86350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86351       };
86352     } catch (...) {
86353       {
86354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86355       };
86356     }
86357   }
86358
86359   jresult = (void *)result;
86360   return jresult;
86361 }
86362
86363
86364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86365   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86366
86367   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86368   {
86369     try {
86370       delete arg1;
86371     } catch (std::out_of_range& e) {
86372       {
86373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86374       };
86375     } catch (std::exception& e) {
86376       {
86377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86378       };
86379     } catch (Dali::DaliException e) {
86380       {
86381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86382       };
86383     } catch (...) {
86384       {
86385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86386       };
86387     }
86388   }
86389
86390 }
86391
86392
86393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86394   void * jresult ;
86395   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86396   Dali::Toolkit::VisualFactory *result = 0 ;
86397
86398   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86399   if (!arg1) {
86400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86401     return 0;
86402   }
86403   {
86404     try {
86405       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86406     } catch (std::out_of_range& e) {
86407       {
86408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86409       };
86410     } catch (std::exception& e) {
86411       {
86412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86413       };
86414     } catch (Dali::DaliException e) {
86415       {
86416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86417       };
86418     } catch (...) {
86419       {
86420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86421       };
86422     }
86423   }
86424
86425   jresult = (void *)result;
86426   return jresult;
86427 }
86428
86429
86430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86431   void * jresult ;
86432   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86433   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86434   Dali::Toolkit::VisualFactory *result = 0 ;
86435
86436   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86437   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86438   if (!arg2) {
86439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86440     return 0;
86441   }
86442   {
86443     try {
86444       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86445     } catch (std::out_of_range& e) {
86446       {
86447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86448       };
86449     } catch (std::exception& e) {
86450       {
86451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86452       };
86453     } catch (Dali::DaliException e) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86456       };
86457     } catch (...) {
86458       {
86459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86460       };
86461     }
86462   }
86463
86464   jresult = (void *)result;
86465   return jresult;
86466 }
86467
86468
86469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86470   void * jresult ;
86471   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86472   Dali::Property::Map *arg2 = 0 ;
86473   Dali::Toolkit::Visual::Base result;
86474
86475   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86476   arg2 = (Dali::Property::Map *)jarg2;
86477   if (!arg2) {
86478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86479     return 0;
86480   }
86481   {
86482     try {
86483       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86484     } catch (std::out_of_range& e) {
86485       {
86486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86487       };
86488     } catch (std::exception& e) {
86489       {
86490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86491       };
86492     } catch (Dali::DaliException e) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86495       };
86496     } catch (...) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86499       };
86500     }
86501   }
86502
86503   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86504   return jresult;
86505 }
86506
86507
86508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86509   void * jresult ;
86510   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86511   std::string *arg2 = 0 ;
86512   Dali::ImageDimensions arg3 ;
86513   Dali::ImageDimensions *argp3 ;
86514   Dali::Toolkit::Visual::Base result;
86515
86516   arg1 = (Dali::Toolkit::VisualFactory *)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   {
86530     try {
86531       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86532     } catch (std::out_of_range& e) {
86533       {
86534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (std::exception& e) {
86537       {
86538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86539       };
86540     } catch (Dali::DaliException e) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86543       };
86544     } catch (...) {
86545       {
86546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86547       };
86548     }
86549   }
86550
86551   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86552
86553   //argout typemap for const std::string&
86554
86555   return jresult;
86556 }
86557
86558
86559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86560   void * jresult ;
86561   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86562
86563   {
86564     try {
86565       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86566     } catch (std::out_of_range& e) {
86567       {
86568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86569       };
86570     } catch (std::exception& e) {
86571       {
86572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86573       };
86574     } catch (Dali::DaliException e) {
86575       {
86576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86577       };
86578     } catch (...) {
86579       {
86580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86581       };
86582     }
86583   }
86584
86585   jresult = (void *)result;
86586   return jresult;
86587 }
86588
86589
86590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86591   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86592
86593   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86594   {
86595     try {
86596       delete arg1;
86597     } catch (std::out_of_range& e) {
86598       {
86599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86600       };
86601     } catch (std::exception& e) {
86602       {
86603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86604       };
86605     } catch (Dali::DaliException e) {
86606       {
86607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86608       };
86609     } catch (...) {
86610       {
86611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86612       };
86613     }
86614   }
86615
86616 }
86617
86618
86619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86620   void * jresult ;
86621   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86622   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86623
86624   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86625   if (!arg1) {
86626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86627     return 0;
86628   }
86629   {
86630     try {
86631       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86632     } catch (std::out_of_range& e) {
86633       {
86634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (std::exception& e) {
86637       {
86638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86639       };
86640     } catch (Dali::DaliException e) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86643       };
86644     } catch (...) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86647       };
86648     }
86649   }
86650
86651   jresult = (void *)result;
86652   return jresult;
86653 }
86654
86655
86656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86657   void * jresult ;
86658   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86659   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86660   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86661
86662   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86663   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86664   if (!arg2) {
86665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86666     return 0;
86667   }
86668   {
86669     try {
86670       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86671     } catch (std::out_of_range& e) {
86672       {
86673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86674       };
86675     } catch (std::exception& e) {
86676       {
86677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86678       };
86679     } catch (Dali::DaliException e) {
86680       {
86681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86682       };
86683     } catch (...) {
86684       {
86685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86686       };
86687     }
86688   }
86689
86690   jresult = (void *)result;
86691   return jresult;
86692 }
86693
86694
86695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86696   void * jresult ;
86697   Dali::Toolkit::AsyncImageLoader result;
86698
86699   {
86700     try {
86701       result = Dali::Toolkit::AsyncImageLoader::New();
86702     } catch (std::out_of_range& e) {
86703       {
86704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86705       };
86706     } catch (std::exception& e) {
86707       {
86708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (Dali::DaliException e) {
86711       {
86712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86713       };
86714     } catch (...) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86717       };
86718     }
86719   }
86720
86721   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86722   return jresult;
86723 }
86724
86725
86726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86727   void * jresult ;
86728   Dali::BaseHandle arg1 ;
86729   Dali::BaseHandle *argp1 ;
86730   Dali::Toolkit::AsyncImageLoader result;
86731
86732   argp1 = (Dali::BaseHandle *)jarg1;
86733   if (!argp1) {
86734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86735     return 0;
86736   }
86737   arg1 = *argp1;
86738   {
86739     try {
86740       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86741     } catch (std::out_of_range& e) {
86742       {
86743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86744       };
86745     } catch (std::exception& e) {
86746       {
86747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86748       };
86749     } catch (Dali::DaliException e) {
86750       {
86751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86752       };
86753     } catch (...) {
86754       {
86755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86756       };
86757     }
86758   }
86759
86760   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86761   return jresult;
86762 }
86763
86764
86765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86766   unsigned int jresult ;
86767   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86768   std::string *arg2 = 0 ;
86769   uint32_t result;
86770
86771   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86772   if (!jarg2) {
86773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86774     return 0;
86775   }
86776   std::string arg2_str(jarg2);
86777   arg2 = &arg2_str;
86778   {
86779     try {
86780       result = (arg1)->Load((std::string const &)*arg2);
86781     } catch (std::out_of_range& e) {
86782       {
86783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86784       };
86785     } catch (std::exception& e) {
86786       {
86787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86788       };
86789     } catch (Dali::DaliException e) {
86790       {
86791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86792       };
86793     } catch (...) {
86794       {
86795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86796       };
86797     }
86798   }
86799
86800   jresult = result;
86801
86802   //argout typemap for const std::string&
86803
86804   return jresult;
86805 }
86806
86807
86808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86809   unsigned int jresult ;
86810   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86811   std::string *arg2 = 0 ;
86812   Dali::ImageDimensions arg3 ;
86813   Dali::ImageDimensions *argp3 ;
86814   uint32_t result;
86815
86816   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86817   if (!jarg2) {
86818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86819     return 0;
86820   }
86821   std::string arg2_str(jarg2);
86822   arg2 = &arg2_str;
86823   argp3 = (Dali::ImageDimensions *)jarg3;
86824   if (!argp3) {
86825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86826     return 0;
86827   }
86828   arg3 = *argp3;
86829   {
86830     try {
86831       result = (arg1)->Load((std::string const &)*arg2,arg3);
86832     } catch (std::out_of_range& e) {
86833       {
86834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86835       };
86836     } catch (std::exception& e) {
86837       {
86838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86839       };
86840     } catch (Dali::DaliException e) {
86841       {
86842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86843       };
86844     } catch (...) {
86845       {
86846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86847       };
86848     }
86849   }
86850
86851   jresult = result;
86852
86853   //argout typemap for const std::string&
86854
86855   return jresult;
86856 }
86857
86858
86859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86860   unsigned int jresult ;
86861   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86862   std::string *arg2 = 0 ;
86863   Dali::ImageDimensions arg3 ;
86864   Dali::FittingMode::Type arg4 ;
86865   Dali::SamplingMode::Type arg5 ;
86866   bool arg6 ;
86867   Dali::ImageDimensions *argp3 ;
86868   uint32_t result;
86869
86870   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86871   if (!jarg2) {
86872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86873     return 0;
86874   }
86875   std::string arg2_str(jarg2);
86876   arg2 = &arg2_str;
86877   argp3 = (Dali::ImageDimensions *)jarg3;
86878   if (!argp3) {
86879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86880     return 0;
86881   }
86882   arg3 = *argp3;
86883   arg4 = (Dali::FittingMode::Type)jarg4;
86884   arg5 = (Dali::SamplingMode::Type)jarg5;
86885   arg6 = jarg6 ? true : false;
86886   {
86887     try {
86888       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86889     } catch (std::out_of_range& e) {
86890       {
86891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86892       };
86893     } catch (std::exception& e) {
86894       {
86895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86896       };
86897     } catch (Dali::DaliException e) {
86898       {
86899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86900       };
86901     } catch (...) {
86902       {
86903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86904       };
86905     }
86906   }
86907
86908   jresult = result;
86909
86910   //argout typemap for const std::string&
86911
86912   return jresult;
86913 }
86914
86915
86916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86917   unsigned int jresult ;
86918   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86919   uint32_t arg2 ;
86920   bool result;
86921
86922   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86923   arg2 = (uint32_t)jarg2;
86924   {
86925     try {
86926       result = (bool)(arg1)->Cancel(arg2);
86927     } catch (std::out_of_range& e) {
86928       {
86929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (std::exception& e) {
86932       {
86933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (Dali::DaliException e) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86942       };
86943     }
86944   }
86945
86946   jresult = result;
86947   return jresult;
86948 }
86949
86950
86951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86952   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86953
86954   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86955   {
86956     try {
86957       (arg1)->CancelAll();
86958     } catch (std::out_of_range& e) {
86959       {
86960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86961       };
86962     } catch (std::exception& e) {
86963       {
86964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86965       };
86966     } catch (Dali::DaliException e) {
86967       {
86968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86969       };
86970     } catch (...) {
86971       {
86972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86973       };
86974     }
86975   }
86976
86977 }
86978
86979
86980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86981   void * jresult ;
86982   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86983   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86984
86985   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86986   {
86987     try {
86988       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86989     } catch (std::out_of_range& e) {
86990       {
86991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86992       };
86993     } catch (std::exception& e) {
86994       {
86995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86996       };
86997     } catch (Dali::DaliException e) {
86998       {
86999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87000       };
87001     } catch (...) {
87002       {
87003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87004       };
87005     }
87006   }
87007
87008   jresult = (void *)result;
87009   return jresult;
87010 }
87011
87012
87013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
87014   void * jresult ;
87015   std::string *arg1 = 0 ;
87016   Dali::PixelData result;
87017
87018   if (!jarg1) {
87019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87020     return 0;
87021   }
87022   std::string arg1_str(jarg1);
87023   arg1 = &arg1_str;
87024   {
87025     try {
87026       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
87027     } catch (std::out_of_range& e) {
87028       {
87029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87030       };
87031     } catch (std::exception& e) {
87032       {
87033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87034       };
87035     } catch (Dali::DaliException e) {
87036       {
87037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87038       };
87039     } catch (...) {
87040       {
87041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87042       };
87043     }
87044   }
87045
87046   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87047
87048   //argout typemap for const std::string&
87049
87050   return jresult;
87051 }
87052
87053
87054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
87055   void * jresult ;
87056   std::string *arg1 = 0 ;
87057   Dali::ImageDimensions arg2 ;
87058   Dali::ImageDimensions *argp2 ;
87059   Dali::PixelData result;
87060
87061   if (!jarg1) {
87062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87063     return 0;
87064   }
87065   std::string arg1_str(jarg1);
87066   arg1 = &arg1_str;
87067   argp2 = (Dali::ImageDimensions *)jarg2;
87068   if (!argp2) {
87069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87070     return 0;
87071   }
87072   arg2 = *argp2;
87073   {
87074     try {
87075       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
87076     } catch (std::out_of_range& e) {
87077       {
87078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87079       };
87080     } catch (std::exception& e) {
87081       {
87082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87083       };
87084     } catch (Dali::DaliException e) {
87085       {
87086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87087       };
87088     } catch (...) {
87089       {
87090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87091       };
87092     }
87093   }
87094
87095   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87096
87097   //argout typemap for const std::string&
87098
87099   return jresult;
87100 }
87101
87102
87103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
87104   void * jresult ;
87105   std::string *arg1 = 0 ;
87106   Dali::ImageDimensions arg2 ;
87107   Dali::FittingMode::Type arg3 ;
87108   Dali::SamplingMode::Type arg4 ;
87109   bool arg5 ;
87110   Dali::ImageDimensions *argp2 ;
87111   Dali::PixelData result;
87112
87113   if (!jarg1) {
87114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87115     return 0;
87116   }
87117   std::string arg1_str(jarg1);
87118   arg1 = &arg1_str;
87119   argp2 = (Dali::ImageDimensions *)jarg2;
87120   if (!argp2) {
87121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87122     return 0;
87123   }
87124   arg2 = *argp2;
87125   arg3 = (Dali::FittingMode::Type)jarg3;
87126   arg4 = (Dali::SamplingMode::Type)jarg4;
87127   arg5 = jarg5 ? true : false;
87128   {
87129     try {
87130       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
87131     } catch (std::out_of_range& e) {
87132       {
87133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87134       };
87135     } catch (std::exception& e) {
87136       {
87137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (Dali::DaliException e) {
87140       {
87141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87142       };
87143     } catch (...) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87146       };
87147     }
87148   }
87149
87150   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87151
87152   //argout typemap for const std::string&
87153
87154   return jresult;
87155 }
87156
87157
87158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
87159   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87160
87161   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87162   {
87163     try {
87164       delete arg1;
87165     } catch (std::out_of_range& e) {
87166       {
87167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87168       };
87169     } catch (std::exception& e) {
87170       {
87171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87172       };
87173     } catch (Dali::DaliException e) {
87174       {
87175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87176       };
87177     } catch (...) {
87178       {
87179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87180       };
87181     }
87182   }
87183
87184 }
87185
87186
87187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87188   void * jresult ;
87189   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87190   Dali::Actor arg2 ;
87191   Dali::Actor arg3 ;
87192   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87193   Dali::Actor *argp2 ;
87194   Dali::Actor *argp3 ;
87195   Dali::Actor result;
87196
87197   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87198   argp2 = (Dali::Actor *)jarg2;
87199   if (!argp2) {
87200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87201     return 0;
87202   }
87203   arg2 = *argp2;
87204   argp3 = (Dali::Actor *)jarg3;
87205   if (!argp3) {
87206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87207     return 0;
87208   }
87209   arg3 = *argp3;
87210   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87211   {
87212     try {
87213       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87214     } catch (std::out_of_range& e) {
87215       {
87216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87217       };
87218     } catch (std::exception& e) {
87219       {
87220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87221       };
87222     } catch (Dali::DaliException e) {
87223       {
87224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87225       };
87226     } catch (...) {
87227       {
87228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87229       };
87230     }
87231   }
87232
87233   jresult = new Dali::Actor((const Dali::Actor &)result);
87234   return jresult;
87235 }
87236
87237
87238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87239   void * jresult ;
87240   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87241
87242   {
87243     try {
87244       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87245     } catch (std::out_of_range& e) {
87246       {
87247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87248       };
87249     } catch (std::exception& e) {
87250       {
87251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87252       };
87253     } catch (Dali::DaliException e) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87256       };
87257     } catch (...) {
87258       {
87259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87260       };
87261     }
87262   }
87263
87264   jresult = (void *)result;
87265   return jresult;
87266 }
87267
87268
87269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87270   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87271   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87272   if (director) {
87273     director->swig_connect_director(callback0);
87274   }
87275 }
87276
87277
87278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87279   void * jresult ;
87280   Dali::FrameCallbackInterface *result = 0 ;
87281
87282   {
87283     try {
87284       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87285     } catch (std::out_of_range& e) {
87286       {
87287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87288       };
87289     } catch (std::exception& e) {
87290       {
87291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87292       };
87293     } catch (Dali::DaliException e) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87296       };
87297     } catch (...) {
87298       {
87299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87300       };
87301     }
87302   }
87303
87304   jresult = (void *)result;
87305   return jresult;
87306 }
87307
87308 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87309   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87310   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87311   return proxy->GetPosition(id, *vector3);
87312 }
87313
87314 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87315   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87316   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87317   return proxy->SetPosition(id, *vector3);
87318 }
87319
87320 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87321   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87322   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87323   return proxy->BakePosition(id, *vector3);
87324 }
87325
87326 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87327   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87328   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87329   return proxy->GetSize(id, *vector3);
87330 }
87331
87332 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87333   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87334   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87335   return proxy->SetSize(id, *vector3);
87336 }
87337 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87338   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87339   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87340   return proxy->BakeSize(id, *vector3);
87341 }
87342
87343 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87344   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87345   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87346   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87347   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87348 }
87349
87350 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87351   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87352   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87353   return proxy->GetScale(id,* vector3);
87354 }
87355
87356 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87357   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87358   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87359   return proxy->SetScale(id, *vector3);
87360 }
87361
87362 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87363   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87364   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87365   return proxy->BakeScale(id, *vector3);
87366 }
87367
87368 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87369   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87370   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87371   return proxy->GetColor(id, *vector4);
87372 }
87373
87374 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87375   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87376   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87377   return proxy->SetColor(id, *vector4);
87378 }
87379
87380 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87381   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87382   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87383   return proxy->BakeColor(id, *vector4);
87384 }
87385
87386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87387   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87388   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87389
87390   Dali::Stage *arg1 = (Dali::Stage *) 0;
87391   Dali::Actor *arg3 = 0;
87392
87393   arg1 = (Dali::Stage *)jarg1;
87394   arg3 = (Dali::Actor *)jarg3;
87395
87396   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87397   return;
87398 }
87399
87400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87401
87402   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87403   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87404
87405   Dali::Stage *arg1 = (Dali::Stage *) 0;
87406
87407   arg1 = (Dali::Stage *)jarg1;
87408
87409   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87410   return;
87411 }
87412
87413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87414   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87415   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87416   if (director) {
87417     director->swig_connect_director(callback0);
87418   }
87419 }
87420
87421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87422   KeyboardFocusManager arg1 ;
87423   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87424   KeyboardFocusManager *argp1 ;
87425
87426   argp1 = (KeyboardFocusManager *)jarg1;
87427   if (!argp1) {
87428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87429     return ;
87430   }
87431   arg1 = *argp1;
87432   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87433   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87434   {
87435     try {
87436       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87437     } catch (std::out_of_range& e) {
87438       {
87439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87440       };
87441     } catch (std::exception& e) {
87442       {
87443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87444       };
87445     } catch (Dali::DaliException e) {
87446       {
87447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87448       };
87449     } catch (...) {
87450       {
87451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87452       };
87453     }
87454   }
87455
87456 }
87457
87458
87459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87460   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87461
87462   arg1 = (std::vector< unsigned int > *)jarg1;
87463   {
87464     try {
87465       (arg1)->clear();
87466     } catch (std::out_of_range& e) {
87467       {
87468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87469       };
87470     } catch (std::exception& e) {
87471       {
87472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87473       };
87474     } catch (Dali::DaliException e) {
87475       {
87476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87477       };
87478     } catch (...) {
87479       {
87480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87481       };
87482     }
87483   }
87484
87485 }
87486
87487
87488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87489   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87490   unsigned int *arg2 = 0 ;
87491   unsigned int temp2 ;
87492
87493   arg1 = (std::vector< unsigned int > *)jarg1;
87494   temp2 = (unsigned int)jarg2;
87495   arg2 = &temp2;
87496   {
87497     try {
87498       (arg1)->push_back((unsigned int const &)*arg2);
87499     } catch (std::out_of_range& e) {
87500       {
87501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87502       };
87503     } catch (std::exception& e) {
87504       {
87505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87506       };
87507     } catch (Dali::DaliException e) {
87508       {
87509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87510       };
87511     } catch (...) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87514       };
87515     }
87516   }
87517
87518 }
87519
87520
87521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87522   unsigned long jresult ;
87523   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87524   std::vector< unsigned int >::size_type result;
87525
87526   arg1 = (std::vector< unsigned int > *)jarg1;
87527   {
87528     try {
87529       result = ((std::vector< unsigned int > const *)arg1)->size();
87530     } catch (std::out_of_range& e) {
87531       {
87532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87533       };
87534     } catch (std::exception& e) {
87535       {
87536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87537       };
87538     } catch (Dali::DaliException e) {
87539       {
87540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87541       };
87542     } catch (...) {
87543       {
87544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87545       };
87546     }
87547   }
87548
87549   jresult = (unsigned long)result;
87550   return jresult;
87551 }
87552
87553
87554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87555   unsigned long jresult ;
87556   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87557   std::vector< unsigned int >::size_type result;
87558
87559   arg1 = (std::vector< unsigned int > *)jarg1;
87560   {
87561     try {
87562       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87563     } catch (std::out_of_range& e) {
87564       {
87565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87566       };
87567     } catch (std::exception& e) {
87568       {
87569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87570       };
87571     } catch (Dali::DaliException e) {
87572       {
87573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87574       };
87575     } catch (...) {
87576       {
87577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87578       };
87579     }
87580   }
87581
87582   jresult = (unsigned long)result;
87583   return jresult;
87584 }
87585
87586
87587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87588   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87589   std::vector< unsigned int >::size_type arg2 ;
87590
87591   arg1 = (std::vector< unsigned int > *)jarg1;
87592   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87593   {
87594     try {
87595       (arg1)->reserve(arg2);
87596     } catch (std::out_of_range& e) {
87597       {
87598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87599       };
87600     } catch (std::exception& e) {
87601       {
87602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87603       };
87604     } catch (Dali::DaliException e) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87607       };
87608     } catch (...) {
87609       {
87610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87611       };
87612     }
87613   }
87614
87615 }
87616
87617
87618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87619   void * jresult ;
87620   std::vector< unsigned int > *result = 0 ;
87621
87622   {
87623     try {
87624       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87625     } catch (std::out_of_range& e) {
87626       {
87627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87628       };
87629     } catch (std::exception& e) {
87630       {
87631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87632       };
87633     } catch (Dali::DaliException e) {
87634       {
87635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87636       };
87637     } catch (...) {
87638       {
87639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87640       };
87641     }
87642   }
87643
87644   jresult = (void *)result;
87645   return jresult;
87646 }
87647
87648
87649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87650   void * jresult ;
87651   std::vector< unsigned int > *arg1 = 0 ;
87652   std::vector< unsigned int > *result = 0 ;
87653
87654   arg1 = (std::vector< unsigned int > *)jarg1;
87655   if (!arg1) {
87656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87657     return 0;
87658   }
87659   {
87660     try {
87661       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87662     } catch (std::out_of_range& e) {
87663       {
87664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87665       };
87666     } catch (std::exception& e) {
87667       {
87668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87669       };
87670     } catch (Dali::DaliException e) {
87671       {
87672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87673       };
87674     } catch (...) {
87675       {
87676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87677       };
87678     }
87679   }
87680
87681   jresult = (void *)result;
87682   return jresult;
87683 }
87684
87685
87686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87687   void * jresult ;
87688   int arg1 ;
87689   std::vector< unsigned int > *result = 0 ;
87690
87691   arg1 = (int)jarg1;
87692   {
87693     try {
87694       try {
87695         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87696       }
87697       catch(std::out_of_range &_e) {
87698         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87699         return 0;
87700       }
87701
87702     } catch (std::out_of_range& e) {
87703       {
87704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87705       };
87706     } catch (std::exception& e) {
87707       {
87708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87709       };
87710     } catch (Dali::DaliException e) {
87711       {
87712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87713       };
87714     } catch (...) {
87715       {
87716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87717       };
87718     }
87719   }
87720
87721   jresult = (void *)result;
87722   return jresult;
87723 }
87724
87725
87726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87727   unsigned int jresult ;
87728   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87729   int arg2 ;
87730   unsigned int result;
87731
87732   arg1 = (std::vector< unsigned int > *)jarg1;
87733   arg2 = (int)jarg2;
87734   {
87735     try {
87736       try {
87737         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87738       }
87739       catch(std::out_of_range &_e) {
87740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87741         return 0;
87742       }
87743
87744     } catch (std::out_of_range& e) {
87745       {
87746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87747       };
87748     } catch (std::exception& e) {
87749       {
87750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87751       };
87752     } catch (Dali::DaliException e) {
87753       {
87754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87755       };
87756     } catch (...) {
87757       {
87758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87759       };
87760     }
87761   }
87762
87763   jresult = result;
87764   return jresult;
87765 }
87766
87767
87768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87769   unsigned int jresult ;
87770   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87771   int arg2 ;
87772   unsigned int *result = 0 ;
87773
87774   arg1 = (std::vector< unsigned int > *)jarg1;
87775   arg2 = (int)jarg2;
87776   {
87777     try {
87778       try {
87779         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87780       }
87781       catch(std::out_of_range &_e) {
87782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87783         return 0;
87784       }
87785
87786     } catch (std::out_of_range& e) {
87787       {
87788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87789       };
87790     } catch (std::exception& e) {
87791       {
87792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87793       };
87794     } catch (Dali::DaliException e) {
87795       {
87796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87797       };
87798     } catch (...) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87801       };
87802     }
87803   }
87804
87805   jresult = *result;
87806   return jresult;
87807 }
87808
87809
87810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87811   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87812   int arg2 ;
87813   unsigned int *arg3 = 0 ;
87814   unsigned int temp3 ;
87815
87816   arg1 = (std::vector< unsigned int > *)jarg1;
87817   arg2 = (int)jarg2;
87818   temp3 = (unsigned int)jarg3;
87819   arg3 = &temp3;
87820   {
87821     try {
87822       try {
87823         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87824       }
87825       catch(std::out_of_range &_e) {
87826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87827         return ;
87828       }
87829
87830     } catch (std::out_of_range& e) {
87831       {
87832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87833       };
87834     } catch (std::exception& e) {
87835       {
87836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87837       };
87838     } catch (Dali::DaliException e) {
87839       {
87840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87841       };
87842     } catch (...) {
87843       {
87844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87845       };
87846     }
87847   }
87848
87849 }
87850
87851
87852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87853   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87854   std::vector< unsigned int > *arg2 = 0 ;
87855
87856   arg1 = (std::vector< unsigned int > *)jarg1;
87857   arg2 = (std::vector< unsigned int > *)jarg2;
87858   if (!arg2) {
87859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87860     return ;
87861   }
87862   {
87863     try {
87864       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87865     } catch (std::out_of_range& e) {
87866       {
87867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87868       };
87869     } catch (std::exception& e) {
87870       {
87871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87872       };
87873     } catch (Dali::DaliException e) {
87874       {
87875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87876       };
87877     } catch (...) {
87878       {
87879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87880       };
87881     }
87882   }
87883
87884 }
87885
87886
87887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87888   void * jresult ;
87889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87890   int arg2 ;
87891   int arg3 ;
87892   std::vector< unsigned int > *result = 0 ;
87893
87894   arg1 = (std::vector< unsigned int > *)jarg1;
87895   arg2 = (int)jarg2;
87896   arg3 = (int)jarg3;
87897   {
87898     try {
87899       try {
87900         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87901       }
87902       catch(std::out_of_range &_e) {
87903         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87904         return 0;
87905       }
87906       catch(std::invalid_argument &_e) {
87907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87908         return 0;
87909       }
87910
87911     } catch (std::out_of_range& e) {
87912       {
87913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87914       };
87915     } catch (std::exception& e) {
87916       {
87917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87918       };
87919     } catch (Dali::DaliException e) {
87920       {
87921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87922       };
87923     } catch (...) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87926       };
87927     }
87928   }
87929
87930   jresult = (void *)result;
87931   return jresult;
87932 }
87933
87934
87935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87936   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87937   int arg2 ;
87938   unsigned int *arg3 = 0 ;
87939   unsigned int temp3 ;
87940
87941   arg1 = (std::vector< unsigned int > *)jarg1;
87942   arg2 = (int)jarg2;
87943   temp3 = (unsigned int)jarg3;
87944   arg3 = &temp3;
87945   {
87946     try {
87947       try {
87948         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87949       }
87950       catch(std::out_of_range &_e) {
87951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87952         return ;
87953       }
87954
87955     } catch (std::out_of_range& e) {
87956       {
87957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87958       };
87959     } catch (std::exception& e) {
87960       {
87961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87962       };
87963     } catch (Dali::DaliException e) {
87964       {
87965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87966       };
87967     } catch (...) {
87968       {
87969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87970       };
87971     }
87972   }
87973
87974 }
87975
87976
87977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87978   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87979   int arg2 ;
87980   std::vector< unsigned int > *arg3 = 0 ;
87981
87982   arg1 = (std::vector< unsigned int > *)jarg1;
87983   arg2 = (int)jarg2;
87984   arg3 = (std::vector< unsigned int > *)jarg3;
87985   if (!arg3) {
87986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87987     return ;
87988   }
87989   {
87990     try {
87991       try {
87992         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87993       }
87994       catch(std::out_of_range &_e) {
87995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87996         return ;
87997       }
87998
87999     } catch (std::out_of_range& e) {
88000       {
88001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88002       };
88003     } catch (std::exception& e) {
88004       {
88005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88006       };
88007     } catch (Dali::DaliException e) {
88008       {
88009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88010       };
88011     } catch (...) {
88012       {
88013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88014       };
88015     }
88016   }
88017
88018 }
88019
88020
88021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
88022   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88023   int arg2 ;
88024
88025   arg1 = (std::vector< unsigned int > *)jarg1;
88026   arg2 = (int)jarg2;
88027   {
88028     try {
88029       try {
88030         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
88031       }
88032       catch(std::out_of_range &_e) {
88033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88034         return ;
88035       }
88036
88037     } catch (std::out_of_range& e) {
88038       {
88039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88040       };
88041     } catch (std::exception& e) {
88042       {
88043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88044       };
88045     } catch (Dali::DaliException e) {
88046       {
88047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88048       };
88049     } catch (...) {
88050       {
88051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88052       };
88053     }
88054   }
88055
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88060   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88061   int arg2 ;
88062   int arg3 ;
88063
88064   arg1 = (std::vector< unsigned int > *)jarg1;
88065   arg2 = (int)jarg2;
88066   arg3 = (int)jarg3;
88067   {
88068     try {
88069       try {
88070         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
88071       }
88072       catch(std::out_of_range &_e) {
88073         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88074         return ;
88075       }
88076       catch(std::invalid_argument &_e) {
88077         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88078         return ;
88079       }
88080
88081     } catch (std::out_of_range& e) {
88082       {
88083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88084       };
88085     } catch (std::exception& e) {
88086       {
88087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88088       };
88089     } catch (Dali::DaliException e) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88092       };
88093     } catch (...) {
88094       {
88095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88096       };
88097     }
88098   }
88099
88100 }
88101
88102
88103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
88104   void * jresult ;
88105   unsigned int *arg1 = 0 ;
88106   int arg2 ;
88107   unsigned int temp1 ;
88108   std::vector< unsigned int > *result = 0 ;
88109
88110   temp1 = (unsigned int)jarg1;
88111   arg1 = &temp1;
88112   arg2 = (int)jarg2;
88113   {
88114     try {
88115       try {
88116         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
88117       }
88118       catch(std::out_of_range &_e) {
88119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88120         return 0;
88121       }
88122
88123     } catch (std::out_of_range& e) {
88124       {
88125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88126       };
88127     } catch (std::exception& e) {
88128       {
88129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88130       };
88131     } catch (Dali::DaliException e) {
88132       {
88133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88134       };
88135     } catch (...) {
88136       {
88137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88138       };
88139     }
88140   }
88141
88142   jresult = (void *)result;
88143   return jresult;
88144 }
88145
88146
88147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
88148   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88149
88150   arg1 = (std::vector< unsigned int > *)jarg1;
88151   {
88152     try {
88153       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
88154     } catch (std::out_of_range& e) {
88155       {
88156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88157       };
88158     } catch (std::exception& e) {
88159       {
88160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (Dali::DaliException e) {
88163       {
88164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88165       };
88166     } catch (...) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88169       };
88170     }
88171   }
88172
88173 }
88174
88175
88176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88177   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88178   int arg2 ;
88179   int arg3 ;
88180
88181   arg1 = (std::vector< unsigned int > *)jarg1;
88182   arg2 = (int)jarg2;
88183   arg3 = (int)jarg3;
88184   {
88185     try {
88186       try {
88187         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88188       }
88189       catch(std::out_of_range &_e) {
88190         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88191         return ;
88192       }
88193       catch(std::invalid_argument &_e) {
88194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88195         return ;
88196       }
88197
88198     } catch (std::out_of_range& e) {
88199       {
88200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88201       };
88202     } catch (std::exception& e) {
88203       {
88204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88205       };
88206     } catch (Dali::DaliException e) {
88207       {
88208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88209       };
88210     } catch (...) {
88211       {
88212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88213       };
88214     }
88215   }
88216
88217 }
88218
88219
88220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88221   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88222   int arg2 ;
88223   std::vector< unsigned int > *arg3 = 0 ;
88224
88225   arg1 = (std::vector< unsigned int > *)jarg1;
88226   arg2 = (int)jarg2;
88227   arg3 = (std::vector< unsigned int > *)jarg3;
88228   if (!arg3) {
88229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88230     return ;
88231   }
88232   {
88233     try {
88234       try {
88235         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88236       }
88237       catch(std::out_of_range &_e) {
88238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88239         return ;
88240       }
88241
88242     } catch (std::out_of_range& e) {
88243       {
88244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88245       };
88246     } catch (std::exception& e) {
88247       {
88248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88249       };
88250     } catch (Dali::DaliException e) {
88251       {
88252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88253       };
88254     } catch (...) {
88255       {
88256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88257       };
88258     }
88259   }
88260
88261 }
88262
88263
88264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88265   unsigned int jresult ;
88266   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88267   unsigned int *arg2 = 0 ;
88268   unsigned int temp2 ;
88269   bool result;
88270
88271   arg1 = (std::vector< unsigned int > *)jarg1;
88272   temp2 = (unsigned int)jarg2;
88273   arg2 = &temp2;
88274   {
88275     try {
88276       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88292       };
88293     }
88294   }
88295
88296   jresult = result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88302   int jresult ;
88303   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88304   unsigned int *arg2 = 0 ;
88305   unsigned int temp2 ;
88306   int result;
88307
88308   arg1 = (std::vector< unsigned int > *)jarg1;
88309   temp2 = (unsigned int)jarg2;
88310   arg2 = &temp2;
88311   {
88312     try {
88313       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88321       };
88322     } catch (Dali::DaliException e) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88325       };
88326     } catch (...) {
88327       {
88328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88329       };
88330     }
88331   }
88332
88333   jresult = result;
88334   return jresult;
88335 }
88336
88337
88338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88339   int jresult ;
88340   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88341   unsigned int *arg2 = 0 ;
88342   unsigned int temp2 ;
88343   int result;
88344
88345   arg1 = (std::vector< unsigned int > *)jarg1;
88346   temp2 = (unsigned int)jarg2;
88347   arg2 = &temp2;
88348   {
88349     try {
88350       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88351     } catch (std::out_of_range& e) {
88352       {
88353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88354       };
88355     } catch (std::exception& e) {
88356       {
88357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88358       };
88359     } catch (Dali::DaliException e) {
88360       {
88361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88362       };
88363     } catch (...) {
88364       {
88365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88366       };
88367     }
88368   }
88369
88370   jresult = result;
88371   return jresult;
88372 }
88373
88374
88375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88376   unsigned int jresult ;
88377   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88378   unsigned int *arg2 = 0 ;
88379   unsigned int temp2 ;
88380   bool result;
88381
88382   arg1 = (std::vector< unsigned int > *)jarg1;
88383   temp2 = (unsigned int)jarg2;
88384   arg2 = &temp2;
88385   {
88386     try {
88387       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88388     } catch (std::out_of_range& e) {
88389       {
88390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88391       };
88392     } catch (std::exception& e) {
88393       {
88394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88395       };
88396     } catch (Dali::DaliException e) {
88397       {
88398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88399       };
88400     } catch (...) {
88401       {
88402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88403       };
88404     }
88405   }
88406
88407   jresult = result;
88408   return jresult;
88409 }
88410
88411
88412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88413   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88414
88415   arg1 = (std::vector< unsigned int > *)jarg1;
88416   {
88417     try {
88418       delete arg1;
88419     } catch (std::out_of_range& e) {
88420       {
88421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88422       };
88423     } catch (std::exception& e) {
88424       {
88425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88426       };
88427     } catch (Dali::DaliException e) {
88428       {
88429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88430       };
88431     } catch (...) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88434       };
88435     }
88436   }
88437
88438 }
88439
88440
88441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88442   void * jresult ;
88443   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88444
88445   {
88446     try {
88447       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88448     } catch (std::out_of_range& e) {
88449       {
88450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88451       };
88452     } catch (std::exception& e) {
88453       {
88454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88455       };
88456     } catch (Dali::DaliException e) {
88457       {
88458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88459       };
88460     } catch (...) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88463       };
88464     }
88465   }
88466
88467   jresult = (void *)result;
88468   return jresult;
88469 }
88470
88471
88472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88473   void * jresult ;
88474   unsigned int arg1 ;
88475   Dali::Actor arg2 ;
88476   Dali::Actor *argp2 ;
88477   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88478
88479   arg1 = (unsigned int)jarg1;
88480   argp2 = (Dali::Actor *)jarg2;
88481   if (!argp2) {
88482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88483     return 0;
88484   }
88485   arg2 = *argp2;
88486   {
88487     try {
88488       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88489     } catch (std::out_of_range& e) {
88490       {
88491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88492       };
88493     } catch (std::exception& e) {
88494       {
88495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88496       };
88497     } catch (Dali::DaliException e) {
88498       {
88499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88500       };
88501     } catch (...) {
88502       {
88503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88504       };
88505     }
88506   }
88507
88508   jresult = (void *)result;
88509   return jresult;
88510 }
88511
88512
88513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88514   void * jresult ;
88515   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88516   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88517
88518   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88519   if (!arg1) {
88520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88521     return 0;
88522   }
88523   {
88524     try {
88525       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88526     } catch (std::out_of_range& e) {
88527       {
88528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88529       };
88530     } catch (std::exception& e) {
88531       {
88532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88533       };
88534     } catch (Dali::DaliException e) {
88535       {
88536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88537       };
88538     } catch (...) {
88539       {
88540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88541       };
88542     }
88543   }
88544
88545   jresult = (void *)result;
88546   return jresult;
88547 }
88548
88549
88550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88551   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88552   unsigned int arg2 ;
88553
88554   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88555   arg2 = (unsigned int)jarg2;
88556   if (arg1) (arg1)->first = arg2;
88557 }
88558
88559
88560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88561   unsigned int jresult ;
88562   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88563   unsigned int result;
88564
88565   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88566   result = (unsigned int) ((arg1)->first);
88567   jresult = result;
88568   return jresult;
88569 }
88570
88571
88572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88573   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88574   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88575
88576   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88577   arg2 = (Dali::Actor *)jarg2;
88578   if (arg1) (arg1)->second = *arg2;
88579 }
88580
88581
88582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88583   void * jresult ;
88584   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88585   Dali::Actor *result = 0 ;
88586
88587   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88588   result = (Dali::Actor *)& ((arg1)->second);
88589   jresult = (void *)result;
88590   return jresult;
88591 }
88592
88593
88594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88595   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88596
88597   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88598   {
88599     try {
88600       delete arg1;
88601     } catch (std::out_of_range& e) {
88602       {
88603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88604       };
88605     } catch (std::exception& e) {
88606       {
88607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88608       };
88609     } catch (Dali::DaliException e) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88612       };
88613     } catch (...) {
88614       {
88615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88616       };
88617     }
88618   }
88619
88620 }
88621
88622
88623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88624   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88625
88626   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88627   {
88628     try {
88629       (arg1)->clear();
88630     } catch (std::out_of_range& e) {
88631       {
88632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88633       };
88634     } catch (std::exception& e) {
88635       {
88636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88637       };
88638     } catch (Dali::DaliException e) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88645       };
88646     }
88647   }
88648
88649 }
88650
88651
88652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88653   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88654   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88655
88656   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88657   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88658   if (!arg2) {
88659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88660     return ;
88661   }
88662   {
88663     try {
88664       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88665     } catch (std::out_of_range& e) {
88666       {
88667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88668       };
88669     } catch (std::exception& e) {
88670       {
88671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88672       };
88673     } catch (Dali::DaliException e) {
88674       {
88675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88680       };
88681     }
88682   }
88683
88684 }
88685
88686
88687 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88688   unsigned long jresult ;
88689   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88690   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88691
88692   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88693   {
88694     try {
88695       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88696     } catch (std::out_of_range& e) {
88697       {
88698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88699       };
88700     } catch (std::exception& e) {
88701       {
88702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88703       };
88704     } catch (Dali::DaliException e) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88711       };
88712     }
88713   }
88714
88715   jresult = (unsigned long)result;
88716   return jresult;
88717 }
88718
88719
88720 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88721   unsigned long jresult ;
88722   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88723   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88724
88725   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88726   {
88727     try {
88728       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88729     } catch (std::out_of_range& e) {
88730       {
88731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88732       };
88733     } catch (std::exception& e) {
88734       {
88735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88736       };
88737     } catch (Dali::DaliException e) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88740       };
88741     } catch (...) {
88742       {
88743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88744       };
88745     }
88746   }
88747
88748   jresult = (unsigned long)result;
88749   return jresult;
88750 }
88751
88752
88753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88754   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88755   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88756
88757   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88758   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88759   {
88760     try {
88761       (arg1)->reserve(arg2);
88762     } catch (std::out_of_range& e) {
88763       {
88764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88765       };
88766     } catch (std::exception& e) {
88767       {
88768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88769       };
88770     } catch (Dali::DaliException e) {
88771       {
88772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88773       };
88774     } catch (...) {
88775       {
88776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88777       };
88778     }
88779   }
88780
88781 }
88782
88783
88784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88785   void * jresult ;
88786   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88787
88788   {
88789     try {
88790       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88791     } catch (std::out_of_range& e) {
88792       {
88793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88794       };
88795     } catch (std::exception& e) {
88796       {
88797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88798       };
88799     } catch (Dali::DaliException e) {
88800       {
88801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88802       };
88803     } catch (...) {
88804       {
88805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88806       };
88807     }
88808   }
88809
88810   jresult = (void *)result;
88811   return jresult;
88812 }
88813
88814
88815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88816   void * jresult ;
88817   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88818   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88819
88820   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88821   if (!arg1) {
88822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88823     return 0;
88824   }
88825   {
88826     try {
88827       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);
88828     } catch (std::out_of_range& e) {
88829       {
88830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88831       };
88832     } catch (std::exception& e) {
88833       {
88834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88835       };
88836     } catch (Dali::DaliException e) {
88837       {
88838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88839       };
88840     } catch (...) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88843       };
88844     }
88845   }
88846
88847   jresult = (void *)result;
88848   return jresult;
88849 }
88850
88851
88852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88853   void * jresult ;
88854   int arg1 ;
88855   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88856
88857   arg1 = (int)jarg1;
88858   {
88859     try {
88860       try {
88861         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);
88862       }
88863       catch(std::out_of_range &_e) {
88864         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88865         return 0;
88866       }
88867
88868     } catch (std::out_of_range& e) {
88869       {
88870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88871       };
88872     } catch (std::exception& e) {
88873       {
88874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (Dali::DaliException e) {
88877       {
88878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88879       };
88880     } catch (...) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88883       };
88884     }
88885   }
88886
88887   jresult = (void *)result;
88888   return jresult;
88889 }
88890
88891
88892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88893   void * jresult ;
88894   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88895   int arg2 ;
88896   std::pair< unsigned int,Dali::Actor > result;
88897
88898   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88899   arg2 = (int)jarg2;
88900   {
88901     try {
88902       try {
88903         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88904       }
88905       catch(std::out_of_range &_e) {
88906         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88907         return 0;
88908       }
88909
88910     } catch (std::out_of_range& e) {
88911       {
88912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88913       };
88914     } catch (std::exception& e) {
88915       {
88916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88917       };
88918     } catch (Dali::DaliException e) {
88919       {
88920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88921       };
88922     } catch (...) {
88923       {
88924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88925       };
88926     }
88927   }
88928
88929   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88930   return jresult;
88931 }
88932
88933
88934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88935   void * jresult ;
88936   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88937   int arg2 ;
88938   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88939
88940   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88941   arg2 = (int)jarg2;
88942   {
88943     try {
88944       try {
88945         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88946       }
88947       catch(std::out_of_range &_e) {
88948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88949         return 0;
88950       }
88951
88952     } catch (std::out_of_range& e) {
88953       {
88954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88955       };
88956     } catch (std::exception& e) {
88957       {
88958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88959       };
88960     } catch (Dali::DaliException e) {
88961       {
88962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88963       };
88964     } catch (...) {
88965       {
88966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88967       };
88968     }
88969   }
88970
88971   jresult = (void *)result;
88972   return jresult;
88973 }
88974
88975
88976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88977   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88978   int arg2 ;
88979   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88980
88981   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88982   arg2 = (int)jarg2;
88983   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88984   if (!arg3) {
88985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88986     return ;
88987   }
88988   {
88989     try {
88990       try {
88991         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);
88992       }
88993       catch(std::out_of_range &_e) {
88994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88995         return ;
88996       }
88997
88998     } catch (std::out_of_range& e) {
88999       {
89000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89001       };
89002     } catch (std::exception& e) {
89003       {
89004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89005       };
89006     } catch (Dali::DaliException e) {
89007       {
89008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89009       };
89010     } catch (...) {
89011       {
89012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89013       };
89014     }
89015   }
89016
89017 }
89018
89019
89020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
89021   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89022   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
89023
89024   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89025   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
89026   if (!arg2) {
89027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89028     return ;
89029   }
89030   {
89031     try {
89032       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);
89033     } catch (std::out_of_range& e) {
89034       {
89035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89036       };
89037     } catch (std::exception& e) {
89038       {
89039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89040       };
89041     } catch (Dali::DaliException e) {
89042       {
89043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89044       };
89045     } catch (...) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89048       };
89049     }
89050   }
89051
89052 }
89053
89054
89055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89056   void * jresult ;
89057   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89058   int arg2 ;
89059   int arg3 ;
89060   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89061
89062   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89063   arg2 = (int)jarg2;
89064   arg3 = (int)jarg3;
89065   {
89066     try {
89067       try {
89068         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);
89069       }
89070       catch(std::out_of_range &_e) {
89071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89072         return 0;
89073       }
89074       catch(std::invalid_argument &_e) {
89075         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89076         return 0;
89077       }
89078
89079     } catch (std::out_of_range& e) {
89080       {
89081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89082       };
89083     } catch (std::exception& e) {
89084       {
89085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89086       };
89087     } catch (Dali::DaliException e) {
89088       {
89089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89090       };
89091     } catch (...) {
89092       {
89093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89094       };
89095     }
89096   }
89097
89098   jresult = (void *)result;
89099   return jresult;
89100 }
89101
89102
89103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89104   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89105   int arg2 ;
89106   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89107
89108   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89109   arg2 = (int)jarg2;
89110   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89111   if (!arg3) {
89112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89113     return ;
89114   }
89115   {
89116     try {
89117       try {
89118         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);
89119       }
89120       catch(std::out_of_range &_e) {
89121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89122         return ;
89123       }
89124
89125     } catch (std::out_of_range& e) {
89126       {
89127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89128       };
89129     } catch (std::exception& e) {
89130       {
89131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89132       };
89133     } catch (Dali::DaliException e) {
89134       {
89135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89136       };
89137     } catch (...) {
89138       {
89139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89140       };
89141     }
89142   }
89143
89144 }
89145
89146
89147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89148   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89149   int arg2 ;
89150   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89151
89152   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89153   arg2 = (int)jarg2;
89154   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89155   if (!arg3) {
89156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89157     return ;
89158   }
89159   {
89160     try {
89161       try {
89162         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);
89163       }
89164       catch(std::out_of_range &_e) {
89165         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89166         return ;
89167       }
89168
89169     } catch (std::out_of_range& e) {
89170       {
89171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89172       };
89173     } catch (std::exception& e) {
89174       {
89175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89176       };
89177     } catch (Dali::DaliException e) {
89178       {
89179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89180       };
89181     } catch (...) {
89182       {
89183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89184       };
89185     }
89186   }
89187
89188 }
89189
89190
89191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89192   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89193   int arg2 ;
89194
89195   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89196   arg2 = (int)jarg2;
89197   {
89198     try {
89199       try {
89200         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89201       }
89202       catch(std::out_of_range &_e) {
89203         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89204         return ;
89205       }
89206
89207     } catch (std::out_of_range& e) {
89208       {
89209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89210       };
89211     } catch (std::exception& e) {
89212       {
89213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89214       };
89215     } catch (Dali::DaliException e) {
89216       {
89217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89218       };
89219     } catch (...) {
89220       {
89221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89222       };
89223     }
89224   }
89225
89226 }
89227
89228
89229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89230   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89231   int arg2 ;
89232   int arg3 ;
89233
89234   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89235   arg2 = (int)jarg2;
89236   arg3 = (int)jarg3;
89237   {
89238     try {
89239       try {
89240         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89241       }
89242       catch(std::out_of_range &_e) {
89243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89244         return ;
89245       }
89246       catch(std::invalid_argument &_e) {
89247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89248         return ;
89249       }
89250
89251     } catch (std::out_of_range& e) {
89252       {
89253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89254       };
89255     } catch (std::exception& e) {
89256       {
89257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89258       };
89259     } catch (Dali::DaliException e) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89262       };
89263     } catch (...) {
89264       {
89265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89266       };
89267     }
89268   }
89269
89270 }
89271
89272
89273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89274   void * jresult ;
89275   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89276   int arg2 ;
89277   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89278
89279   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89280   if (!arg1) {
89281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89282     return 0;
89283   }
89284   arg2 = (int)jarg2;
89285   {
89286     try {
89287       try {
89288         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);
89289       }
89290       catch(std::out_of_range &_e) {
89291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89292         return 0;
89293       }
89294
89295     } catch (std::out_of_range& e) {
89296       {
89297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89298       };
89299     } catch (std::exception& e) {
89300       {
89301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89302       };
89303     } catch (Dali::DaliException e) {
89304       {
89305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89306       };
89307     } catch (...) {
89308       {
89309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89310       };
89311     }
89312   }
89313
89314   jresult = (void *)result;
89315   return jresult;
89316 }
89317
89318
89319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89320   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89321
89322   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89323   {
89324     try {
89325       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89326     } catch (std::out_of_range& e) {
89327       {
89328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89329       };
89330     } catch (std::exception& e) {
89331       {
89332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89333       };
89334     } catch (Dali::DaliException e) {
89335       {
89336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89337       };
89338     } catch (...) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89341       };
89342     }
89343   }
89344
89345 }
89346
89347
89348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89349   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89350   int arg2 ;
89351   int arg3 ;
89352
89353   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89354   arg2 = (int)jarg2;
89355   arg3 = (int)jarg3;
89356   {
89357     try {
89358       try {
89359         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89360       }
89361       catch(std::out_of_range &_e) {
89362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89363         return ;
89364       }
89365       catch(std::invalid_argument &_e) {
89366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89367         return ;
89368       }
89369
89370     } catch (std::out_of_range& e) {
89371       {
89372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (std::exception& e) {
89375       {
89376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89377       };
89378     } catch (Dali::DaliException e) {
89379       {
89380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89381       };
89382     } catch (...) {
89383       {
89384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89385       };
89386     }
89387   }
89388
89389 }
89390
89391
89392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89393   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89394   int arg2 ;
89395   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89396
89397   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89398   arg2 = (int)jarg2;
89399   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89400   if (!arg3) {
89401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89402     return ;
89403   }
89404   {
89405     try {
89406       try {
89407         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);
89408       }
89409       catch(std::out_of_range &_e) {
89410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89411         return ;
89412       }
89413
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (Dali::DaliException e) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89425       };
89426     } catch (...) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89429       };
89430     }
89431   }
89432
89433 }
89434
89435
89436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89437   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89438
89439   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89440   {
89441     try {
89442       delete arg1;
89443     } catch (std::out_of_range& e) {
89444       {
89445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89446       };
89447     } catch (std::exception& e) {
89448       {
89449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89450       };
89451     } catch (Dali::DaliException e) {
89452       {
89453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89454       };
89455     } catch (...) {
89456       {
89457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89458       };
89459     }
89460   }
89461
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89466   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89467
89468   arg1 = (std::vector< Dali::Actor > *)jarg1;
89469   {
89470     try {
89471       (arg1)->clear();
89472     } catch (std::out_of_range& e) {
89473       {
89474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (std::exception& e) {
89477       {
89478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (Dali::DaliException e) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89483       };
89484     } catch (...) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89487       };
89488     }
89489   }
89490
89491 }
89492
89493
89494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89495   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89496   Dali::Actor *arg2 = 0 ;
89497
89498   arg1 = (std::vector< Dali::Actor > *)jarg1;
89499   arg2 = (Dali::Actor *)jarg2;
89500   if (!arg2) {
89501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89502     return ;
89503   }
89504   {
89505     try {
89506       (arg1)->push_back((Dali::Actor const &)*arg2);
89507     } catch (std::out_of_range& e) {
89508       {
89509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89510       };
89511     } catch (std::exception& e) {
89512       {
89513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89514       };
89515     } catch (Dali::DaliException e) {
89516       {
89517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89518       };
89519     } catch (...) {
89520       {
89521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89522       };
89523     }
89524   }
89525
89526 }
89527
89528
89529 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89530   unsigned long jresult ;
89531   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89532   std::vector< Dali::Actor >::size_type result;
89533
89534   arg1 = (std::vector< Dali::Actor > *)jarg1;
89535   {
89536     try {
89537       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89538     } catch (std::out_of_range& e) {
89539       {
89540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89541       };
89542     } catch (std::exception& e) {
89543       {
89544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89545       };
89546     } catch (Dali::DaliException e) {
89547       {
89548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89549       };
89550     } catch (...) {
89551       {
89552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89553       };
89554     }
89555   }
89556
89557   jresult = (unsigned long)result;
89558   return jresult;
89559 }
89560
89561
89562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89563   unsigned long jresult ;
89564   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89565   std::vector< Dali::Actor >::size_type result;
89566
89567   arg1 = (std::vector< Dali::Actor > *)jarg1;
89568   {
89569     try {
89570       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89571     } catch (std::out_of_range& e) {
89572       {
89573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89574       };
89575     } catch (std::exception& e) {
89576       {
89577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89578       };
89579     } catch (Dali::DaliException e) {
89580       {
89581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89582       };
89583     } catch (...) {
89584       {
89585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89586       };
89587     }
89588   }
89589
89590   jresult = (unsigned long)result;
89591   return jresult;
89592 }
89593
89594
89595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89596   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89597   std::vector< Dali::Actor >::size_type arg2 ;
89598
89599   arg1 = (std::vector< Dali::Actor > *)jarg1;
89600   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89601   {
89602     try {
89603       (arg1)->reserve(arg2);
89604     } catch (std::out_of_range& e) {
89605       {
89606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89607       };
89608     } catch (std::exception& e) {
89609       {
89610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89611       };
89612     } catch (Dali::DaliException e) {
89613       {
89614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89615       };
89616     } catch (...) {
89617       {
89618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89619       };
89620     }
89621   }
89622
89623 }
89624
89625
89626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89627   void * jresult ;
89628   std::vector< Dali::Actor > *result = 0 ;
89629
89630   {
89631     try {
89632       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89633     } catch (std::out_of_range& e) {
89634       {
89635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89636       };
89637     } catch (std::exception& e) {
89638       {
89639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (Dali::DaliException e) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89644       };
89645     } catch (...) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89648       };
89649     }
89650   }
89651
89652   jresult = (void *)result;
89653   return jresult;
89654 }
89655
89656
89657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89658   void * jresult ;
89659   std::vector< Dali::Actor > *arg1 = 0 ;
89660   std::vector< Dali::Actor > *result = 0 ;
89661
89662   arg1 = (std::vector< Dali::Actor > *)jarg1;
89663   if (!arg1) {
89664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89665     return 0;
89666   }
89667   {
89668     try {
89669       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89670     } catch (std::out_of_range& e) {
89671       {
89672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89673       };
89674     } catch (std::exception& e) {
89675       {
89676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89677       };
89678     } catch (Dali::DaliException e) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89681       };
89682     } catch (...) {
89683       {
89684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89685       };
89686     }
89687   }
89688
89689   jresult = (void *)result;
89690   return jresult;
89691 }
89692
89693
89694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89695   void * jresult ;
89696   int arg1 ;
89697   std::vector< Dali::Actor > *result = 0 ;
89698
89699   arg1 = (int)jarg1;
89700   {
89701     try {
89702       try {
89703         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89704       }
89705       catch(std::out_of_range &_e) {
89706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89707         return 0;
89708       }
89709
89710     } catch (std::out_of_range& e) {
89711       {
89712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89713       };
89714     } catch (std::exception& e) {
89715       {
89716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89717       };
89718     } catch (Dali::DaliException e) {
89719       {
89720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89721       };
89722     } catch (...) {
89723       {
89724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89725       };
89726     }
89727   }
89728
89729   jresult = (void *)result;
89730   return jresult;
89731 }
89732
89733
89734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89735   void * jresult ;
89736   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89737   int arg2 ;
89738   Dali::Actor result;
89739
89740   arg1 = (std::vector< Dali::Actor > *)jarg1;
89741   arg2 = (int)jarg2;
89742   {
89743     try {
89744       try {
89745         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89746       }
89747       catch(std::out_of_range &_e) {
89748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89749         return 0;
89750       }
89751
89752     } catch (std::out_of_range& e) {
89753       {
89754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89755       };
89756     } catch (std::exception& e) {
89757       {
89758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89759       };
89760     } catch (Dali::DaliException e) {
89761       {
89762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89763       };
89764     } catch (...) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89767       };
89768     }
89769   }
89770
89771   jresult = new Dali::Actor((const Dali::Actor &)result);
89772   return jresult;
89773 }
89774
89775
89776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89777   void * jresult ;
89778   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89779   int arg2 ;
89780   Dali::Actor *result = 0 ;
89781
89782   arg1 = (std::vector< Dali::Actor > *)jarg1;
89783   arg2 = (int)jarg2;
89784   {
89785     try {
89786       try {
89787         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89788       }
89789       catch(std::out_of_range &_e) {
89790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89791         return 0;
89792       }
89793
89794     } catch (std::out_of_range& e) {
89795       {
89796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89797       };
89798     } catch (std::exception& e) {
89799       {
89800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89801       };
89802     } catch (Dali::DaliException e) {
89803       {
89804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89805       };
89806     } catch (...) {
89807       {
89808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89809       };
89810     }
89811   }
89812
89813   jresult = (void *)result;
89814   return jresult;
89815 }
89816
89817
89818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89820   int arg2 ;
89821   Dali::Actor *arg3 = 0 ;
89822
89823   arg1 = (std::vector< Dali::Actor > *)jarg1;
89824   arg2 = (int)jarg2;
89825   arg3 = (Dali::Actor *)jarg3;
89826   if (!arg3) {
89827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89828     return ;
89829   }
89830   {
89831     try {
89832       try {
89833         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89834       }
89835       catch(std::out_of_range &_e) {
89836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89837         return ;
89838       }
89839
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89847       };
89848     } catch (Dali::DaliException e) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89851       };
89852     } catch (...) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89855       };
89856     }
89857   }
89858
89859 }
89860
89861
89862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89863   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89864   std::vector< Dali::Actor > *arg2 = 0 ;
89865
89866   arg1 = (std::vector< Dali::Actor > *)jarg1;
89867   arg2 = (std::vector< Dali::Actor > *)jarg2;
89868   if (!arg2) {
89869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89870     return ;
89871   }
89872   {
89873     try {
89874       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89875     } catch (std::out_of_range& e) {
89876       {
89877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (std::exception& e) {
89880       {
89881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (Dali::DaliException e) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89886       };
89887     } catch (...) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89890       };
89891     }
89892   }
89893
89894 }
89895
89896
89897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89898   void * jresult ;
89899   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89900   int arg2 ;
89901   int arg3 ;
89902   std::vector< Dali::Actor > *result = 0 ;
89903
89904   arg1 = (std::vector< Dali::Actor > *)jarg1;
89905   arg2 = (int)jarg2;
89906   arg3 = (int)jarg3;
89907   {
89908     try {
89909       try {
89910         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89911       }
89912       catch(std::out_of_range &_e) {
89913         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89914         return 0;
89915       }
89916       catch(std::invalid_argument &_e) {
89917         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89918         return 0;
89919       }
89920
89921     } catch (std::out_of_range& e) {
89922       {
89923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89924       };
89925     } catch (std::exception& e) {
89926       {
89927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89928       };
89929     } catch (Dali::DaliException e) {
89930       {
89931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89932       };
89933     } catch (...) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89936       };
89937     }
89938   }
89939
89940   jresult = (void *)result;
89941   return jresult;
89942 }
89943
89944
89945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89946   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89947   int arg2 ;
89948   Dali::Actor *arg3 = 0 ;
89949
89950   arg1 = (std::vector< Dali::Actor > *)jarg1;
89951   arg2 = (int)jarg2;
89952   arg3 = (Dali::Actor *)jarg3;
89953   if (!arg3) {
89954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89955     return ;
89956   }
89957   {
89958     try {
89959       try {
89960         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89961       }
89962       catch(std::out_of_range &_e) {
89963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89964         return ;
89965       }
89966
89967     } catch (std::out_of_range& e) {
89968       {
89969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89970       };
89971     } catch (std::exception& e) {
89972       {
89973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89974       };
89975     } catch (Dali::DaliException e) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89978       };
89979     } catch (...) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89982       };
89983     }
89984   }
89985
89986 }
89987
89988
89989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89990   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89991   int arg2 ;
89992   std::vector< Dali::Actor > *arg3 = 0 ;
89993
89994   arg1 = (std::vector< Dali::Actor > *)jarg1;
89995   arg2 = (int)jarg2;
89996   arg3 = (std::vector< Dali::Actor > *)jarg3;
89997   if (!arg3) {
89998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89999     return ;
90000   }
90001   {
90002     try {
90003       try {
90004         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90005       }
90006       catch(std::out_of_range &_e) {
90007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90008         return ;
90009       }
90010
90011     } catch (std::out_of_range& e) {
90012       {
90013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (std::exception& e) {
90016       {
90017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90018       };
90019     } catch (Dali::DaliException e) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90022       };
90023     } catch (...) {
90024       {
90025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90026       };
90027     }
90028   }
90029
90030 }
90031
90032
90033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
90034   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90035   int arg2 ;
90036
90037   arg1 = (std::vector< Dali::Actor > *)jarg1;
90038   arg2 = (int)jarg2;
90039   {
90040     try {
90041       try {
90042         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
90043       }
90044       catch(std::out_of_range &_e) {
90045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90046         return ;
90047       }
90048
90049     } catch (std::out_of_range& e) {
90050       {
90051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90052       };
90053     } catch (std::exception& e) {
90054       {
90055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90056       };
90057     } catch (Dali::DaliException e) {
90058       {
90059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90060       };
90061     } catch (...) {
90062       {
90063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90064       };
90065     }
90066   }
90067
90068 }
90069
90070
90071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90072   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90073   int arg2 ;
90074   int arg3 ;
90075
90076   arg1 = (std::vector< Dali::Actor > *)jarg1;
90077   arg2 = (int)jarg2;
90078   arg3 = (int)jarg3;
90079   {
90080     try {
90081       try {
90082         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
90083       }
90084       catch(std::out_of_range &_e) {
90085         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90086         return ;
90087       }
90088       catch(std::invalid_argument &_e) {
90089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90090         return ;
90091       }
90092
90093     } catch (std::out_of_range& e) {
90094       {
90095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90096       };
90097     } catch (std::exception& e) {
90098       {
90099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90100       };
90101     } catch (Dali::DaliException e) {
90102       {
90103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90104       };
90105     } catch (...) {
90106       {
90107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90108       };
90109     }
90110   }
90111
90112 }
90113
90114
90115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
90116   void * jresult ;
90117   Dali::Actor *arg1 = 0 ;
90118   int arg2 ;
90119   std::vector< Dali::Actor > *result = 0 ;
90120
90121   arg1 = (Dali::Actor *)jarg1;
90122   if (!arg1) {
90123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90124     return 0;
90125   }
90126   arg2 = (int)jarg2;
90127   {
90128     try {
90129       try {
90130         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
90131       }
90132       catch(std::out_of_range &_e) {
90133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90134         return 0;
90135       }
90136
90137     } catch (std::out_of_range& e) {
90138       {
90139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90140       };
90141     } catch (std::exception& e) {
90142       {
90143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90144       };
90145     } catch (Dali::DaliException e) {
90146       {
90147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90148       };
90149     } catch (...) {
90150       {
90151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90152       };
90153     }
90154   }
90155
90156   jresult = (void *)result;
90157   return jresult;
90158 }
90159
90160
90161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
90162   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90163
90164   arg1 = (std::vector< Dali::Actor > *)jarg1;
90165   {
90166     try {
90167       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
90168     } catch (std::out_of_range& e) {
90169       {
90170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90171       };
90172     } catch (std::exception& e) {
90173       {
90174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90175       };
90176     } catch (Dali::DaliException e) {
90177       {
90178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90179       };
90180     } catch (...) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90183       };
90184     }
90185   }
90186
90187 }
90188
90189
90190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90191   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90192   int arg2 ;
90193   int arg3 ;
90194
90195   arg1 = (std::vector< Dali::Actor > *)jarg1;
90196   arg2 = (int)jarg2;
90197   arg3 = (int)jarg3;
90198   {
90199     try {
90200       try {
90201         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90202       }
90203       catch(std::out_of_range &_e) {
90204         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90205         return ;
90206       }
90207       catch(std::invalid_argument &_e) {
90208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90209         return ;
90210       }
90211
90212     } catch (std::out_of_range& e) {
90213       {
90214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90215       };
90216     } catch (std::exception& e) {
90217       {
90218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90219       };
90220     } catch (Dali::DaliException e) {
90221       {
90222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90223       };
90224     } catch (...) {
90225       {
90226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90227       };
90228     }
90229   }
90230
90231 }
90232
90233
90234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90235   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90236   int arg2 ;
90237   std::vector< Dali::Actor > *arg3 = 0 ;
90238
90239   arg1 = (std::vector< Dali::Actor > *)jarg1;
90240   arg2 = (int)jarg2;
90241   arg3 = (std::vector< Dali::Actor > *)jarg3;
90242   if (!arg3) {
90243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90244     return ;
90245   }
90246   {
90247     try {
90248       try {
90249         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90250       }
90251       catch(std::out_of_range &_e) {
90252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90253         return ;
90254       }
90255
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90263       };
90264     } catch (Dali::DaliException e) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90267       };
90268     } catch (...) {
90269       {
90270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90271       };
90272     }
90273   }
90274
90275 }
90276
90277
90278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90279   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90280
90281   arg1 = (std::vector< Dali::Actor > *)jarg1;
90282   {
90283     try {
90284       delete arg1;
90285     } catch (std::out_of_range& e) {
90286       {
90287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90288       };
90289     } catch (std::exception& e) {
90290       {
90291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90292       };
90293     } catch (Dali::DaliException e) {
90294       {
90295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90296       };
90297     } catch (...) {
90298       {
90299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90300       };
90301     }
90302   }
90303
90304 }
90305
90306
90307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90308   unsigned int jresult ;
90309   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90310   bool result;
90311
90312   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90313   {
90314     try {
90315       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90316     } catch (std::out_of_range& e) {
90317       {
90318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90319       };
90320     } catch (std::exception& e) {
90321       {
90322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90323       };
90324     } catch (Dali::DaliException e) {
90325       {
90326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90327       };
90328     } catch (...) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90331       };
90332     }
90333   }
90334
90335   jresult = result;
90336   return jresult;
90337 }
90338
90339
90340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90341   unsigned long jresult ;
90342   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90343   std::size_t result;
90344
90345   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90346   {
90347     try {
90348       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90349     } catch (std::out_of_range& e) {
90350       {
90351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90352       };
90353     } catch (std::exception& e) {
90354       {
90355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90356       };
90357     } catch (Dali::DaliException e) {
90358       {
90359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90360       };
90361     } catch (...) {
90362       {
90363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90364       };
90365     }
90366   }
90367
90368   jresult = (unsigned long)result;
90369   return jresult;
90370 }
90371
90372
90373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90374   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90375   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90376
90377   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90378   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90379   {
90380     try {
90381       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90382     } catch (std::out_of_range& e) {
90383       {
90384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90385       };
90386     } catch (std::exception& e) {
90387       {
90388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90389       };
90390     } catch (Dali::DaliException e) {
90391       {
90392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90393       };
90394     } catch (...) {
90395       {
90396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90397       };
90398     }
90399   }
90400
90401 }
90402
90403
90404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90405   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90406   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90407
90408   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90409   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90410   {
90411     try {
90412       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90413     } catch (std::out_of_range& e) {
90414       {
90415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90416       };
90417     } catch (std::exception& e) {
90418       {
90419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90420       };
90421     } catch (Dali::DaliException e) {
90422       {
90423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90424       };
90425     } catch (...) {
90426       {
90427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90428       };
90429     }
90430   }
90431
90432 }
90433
90434
90435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90436   unsigned int jresult ;
90437   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90438   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90439   bool result;
90440
90441   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90442   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90443   if (!arg2) {
90444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90445     return 0;
90446   }
90447   {
90448     try {
90449       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90450     } catch (std::out_of_range& e) {
90451       {
90452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90453       };
90454     } catch (std::exception& e) {
90455       {
90456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90457       };
90458     } catch (Dali::DaliException e) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90461       };
90462     } catch (...) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90465       };
90466     }
90467   }
90468
90469   jresult = result;
90470   return jresult;
90471 }
90472
90473
90474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90475   void * jresult ;
90476   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90477
90478   {
90479     try {
90480       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90481     } catch (std::out_of_range& e) {
90482       {
90483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90484       };
90485     } catch (std::exception& e) {
90486       {
90487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90488       };
90489     } catch (Dali::DaliException e) {
90490       {
90491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90492       };
90493     } catch (...) {
90494       {
90495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90496       };
90497     }
90498   }
90499
90500   jresult = (void *)result;
90501   return jresult;
90502 }
90503
90504
90505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90506   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90507
90508   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90509   {
90510     try {
90511       delete arg1;
90512     } catch (std::out_of_range& e) {
90513       {
90514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90515       };
90516     } catch (std::exception& e) {
90517       {
90518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90519       };
90520     } catch (Dali::DaliException e) {
90521       {
90522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90523       };
90524     } catch (...) {
90525       {
90526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90527       };
90528     }
90529   }
90530
90531 }
90532
90533
90534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90535   unsigned int jresult ;
90536   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90537   bool result;
90538
90539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90540   {
90541     try {
90542       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);
90543     } catch (std::out_of_range& e) {
90544       {
90545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90546       };
90547     } catch (std::exception& e) {
90548       {
90549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90550       };
90551     } catch (Dali::DaliException e) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90554       };
90555     } catch (...) {
90556       {
90557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90558       };
90559     }
90560   }
90561
90562   jresult = result;
90563   return jresult;
90564 }
90565
90566
90567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90568   unsigned long jresult ;
90569   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90570   std::size_t result;
90571
90572   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90573   {
90574     try {
90575       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);
90576     } catch (std::out_of_range& e) {
90577       {
90578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (std::exception& e) {
90581       {
90582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90583       };
90584     } catch (Dali::DaliException e) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90587       };
90588     } catch (...) {
90589       {
90590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90591       };
90592     }
90593   }
90594
90595   jresult = (unsigned long)result;
90596   return jresult;
90597 }
90598
90599
90600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90601   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90602   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90603
90604   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90605   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90606   {
90607     try {
90608       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90609     } catch (std::out_of_range& e) {
90610       {
90611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90612       };
90613     } catch (std::exception& e) {
90614       {
90615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90616       };
90617     } catch (Dali::DaliException e) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90620       };
90621     } catch (...) {
90622       {
90623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90624       };
90625     }
90626   }
90627
90628 }
90629
90630
90631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90632   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90633   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90634
90635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90636   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90637   {
90638     try {
90639       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90640     } catch (std::out_of_range& e) {
90641       {
90642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90643       };
90644     } catch (std::exception& e) {
90645       {
90646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90647       };
90648     } catch (Dali::DaliException e) {
90649       {
90650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90651       };
90652     } catch (...) {
90653       {
90654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90655       };
90656     }
90657   }
90658
90659 }
90660
90661
90662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90663   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90664   Dali::Actor arg2 ;
90665   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90666   Dali::Actor *argp2 ;
90667
90668   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90669   argp2 = (Dali::Actor *)jarg2;
90670   if (!argp2) {
90671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90672     return ;
90673   }
90674   arg2 = *argp2;
90675   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90676   {
90677     try {
90678       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90679     } catch (std::out_of_range& e) {
90680       {
90681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90682       };
90683     } catch (std::exception& e) {
90684       {
90685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90686       };
90687     } catch (Dali::DaliException e) {
90688       {
90689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90690       };
90691     } catch (...) {
90692       {
90693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90694       };
90695     }
90696   }
90697
90698 }
90699
90700
90701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90702   void * jresult ;
90703   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90704
90705   {
90706     try {
90707       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90708     } catch (std::out_of_range& e) {
90709       {
90710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90711       };
90712     } catch (std::exception& e) {
90713       {
90714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90715       };
90716     } catch (Dali::DaliException e) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90719       };
90720     } catch (...) {
90721       {
90722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90723       };
90724     }
90725   }
90726
90727   jresult = (void *)result;
90728   return jresult;
90729 }
90730
90731
90732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90733   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90734
90735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90736   {
90737     try {
90738       delete arg1;
90739     } catch (std::out_of_range& e) {
90740       {
90741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90742       };
90743     } catch (std::exception& e) {
90744       {
90745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90746       };
90747     } catch (Dali::DaliException e) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90750       };
90751     } catch (...) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90754       };
90755     }
90756   }
90757
90758 }
90759
90760
90761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90762   unsigned int jresult ;
90763   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90764   bool result;
90765
90766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90767   {
90768     try {
90769       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90770     } catch (std::out_of_range& e) {
90771       {
90772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90773       };
90774     } catch (std::exception& e) {
90775       {
90776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90777       };
90778     } catch (Dali::DaliException e) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90781       };
90782     } catch (...) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90785       };
90786     }
90787   }
90788
90789   jresult = result;
90790   return jresult;
90791 }
90792
90793
90794 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90795   unsigned long jresult ;
90796   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90797   std::size_t result;
90798
90799   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90800   {
90801     try {
90802       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90803     } catch (std::out_of_range& e) {
90804       {
90805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90806       };
90807     } catch (std::exception& e) {
90808       {
90809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90810       };
90811     } catch (Dali::DaliException e) {
90812       {
90813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90814       };
90815     } catch (...) {
90816       {
90817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90818       };
90819     }
90820   }
90821
90822   jresult = (unsigned long)result;
90823   return jresult;
90824 }
90825
90826
90827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90828   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90829   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90830
90831   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90832   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90833   {
90834     try {
90835       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90836     } catch (std::out_of_range& e) {
90837       {
90838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90839       };
90840     } catch (std::exception& e) {
90841       {
90842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90843       };
90844     } catch (Dali::DaliException e) {
90845       {
90846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90847       };
90848     } catch (...) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90851       };
90852     }
90853   }
90854
90855 }
90856
90857
90858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90859   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90860   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90861
90862   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90863   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90864   {
90865     try {
90866       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90867     } catch (std::out_of_range& e) {
90868       {
90869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90870       };
90871     } catch (std::exception& e) {
90872       {
90873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90874       };
90875     } catch (Dali::DaliException e) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90878       };
90879     } catch (...) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90882       };
90883     }
90884   }
90885
90886 }
90887
90888
90889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90890   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90891   Dali::Actor arg2 ;
90892   Dali::Actor arg3 ;
90893   Dali::Actor *argp2 ;
90894   Dali::Actor *argp3 ;
90895
90896   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90897   argp2 = (Dali::Actor *)jarg2;
90898   if (!argp2) {
90899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90900     return ;
90901   }
90902   arg2 = *argp2;
90903   argp3 = (Dali::Actor *)jarg3;
90904   if (!argp3) {
90905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90906     return ;
90907   }
90908   arg3 = *argp3;
90909   {
90910     try {
90911       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90912     } catch (std::out_of_range& e) {
90913       {
90914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90915       };
90916     } catch (std::exception& e) {
90917       {
90918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90919       };
90920     } catch (Dali::DaliException e) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90923       };
90924     } catch (...) {
90925       {
90926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90927       };
90928     }
90929   }
90930
90931 }
90932
90933
90934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90935   void * jresult ;
90936   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90937
90938   {
90939     try {
90940       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90941     } catch (std::out_of_range& e) {
90942       {
90943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90944       };
90945     } catch (std::exception& e) {
90946       {
90947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90948       };
90949     } catch (Dali::DaliException e) {
90950       {
90951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90952       };
90953     } catch (...) {
90954       {
90955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90956       };
90957     }
90958   }
90959
90960   jresult = (void *)result;
90961   return jresult;
90962 }
90963
90964
90965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90966   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90967
90968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90969   {
90970     try {
90971       delete arg1;
90972     } catch (std::out_of_range& e) {
90973       {
90974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90975       };
90976     } catch (std::exception& e) {
90977       {
90978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90979       };
90980     } catch (Dali::DaliException e) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90983       };
90984     } catch (...) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90987       };
90988     }
90989   }
90990
90991 }
90992
90993
90994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90995   unsigned int jresult ;
90996   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90997   bool result;
90998
90999   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91000   {
91001     try {
91002       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91003     } catch (std::out_of_range& e) {
91004       {
91005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91006       };
91007     } catch (std::exception& e) {
91008       {
91009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91010       };
91011     } catch (Dali::DaliException e) {
91012       {
91013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91014       };
91015     } catch (...) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91018       };
91019     }
91020   }
91021
91022   jresult = result;
91023   return jresult;
91024 }
91025
91026
91027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
91028   unsigned long jresult ;
91029   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91030   std::size_t result;
91031
91032   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91033   {
91034     try {
91035       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91036     } catch (std::out_of_range& e) {
91037       {
91038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (std::exception& e) {
91041       {
91042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91043       };
91044     } catch (Dali::DaliException e) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91047       };
91048     } catch (...) {
91049       {
91050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91051       };
91052     }
91053   }
91054
91055   jresult = (unsigned long)result;
91056   return jresult;
91057 }
91058
91059
91060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
91061   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91062   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91063
91064   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91065   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91066   {
91067     try {
91068       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
91069     } catch (std::out_of_range& e) {
91070       {
91071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91072       };
91073     } catch (std::exception& e) {
91074       {
91075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (Dali::DaliException e) {
91078       {
91079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91080       };
91081     } catch (...) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91084       };
91085     }
91086   }
91087
91088 }
91089
91090
91091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91092   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91093   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91094
91095   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91096   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91097   {
91098     try {
91099       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91100     } catch (std::out_of_range& e) {
91101       {
91102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91103       };
91104     } catch (std::exception& e) {
91105       {
91106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91107       };
91108     } catch (Dali::DaliException e) {
91109       {
91110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91111       };
91112     } catch (...) {
91113       {
91114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91115       };
91116     }
91117   }
91118
91119 }
91120
91121
91122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
91123   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91124   Dali::Actor arg2 ;
91125   bool arg3 ;
91126   Dali::Actor *argp2 ;
91127
91128   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91129   argp2 = (Dali::Actor *)jarg2;
91130   if (!argp2) {
91131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91132     return ;
91133   }
91134   arg2 = *argp2;
91135   arg3 = jarg3 ? true : false;
91136   {
91137     try {
91138       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
91139     } catch (std::out_of_range& e) {
91140       {
91141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91142       };
91143     } catch (std::exception& e) {
91144       {
91145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91146       };
91147     } catch (Dali::DaliException e) {
91148       {
91149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91150       };
91151     } catch (...) {
91152       {
91153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91154       };
91155     }
91156   }
91157
91158 }
91159
91160
91161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
91162   void * jresult ;
91163   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
91164
91165   {
91166     try {
91167       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
91168     } catch (std::out_of_range& e) {
91169       {
91170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91171       };
91172     } catch (std::exception& e) {
91173       {
91174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91175       };
91176     } catch (Dali::DaliException e) {
91177       {
91178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91179       };
91180     } catch (...) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91183       };
91184     }
91185   }
91186
91187   jresult = (void *)result;
91188   return jresult;
91189 }
91190
91191
91192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91193   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91194
91195   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91196   {
91197     try {
91198       delete arg1;
91199     } catch (std::out_of_range& e) {
91200       {
91201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91202       };
91203     } catch (std::exception& e) {
91204       {
91205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91206       };
91207     } catch (Dali::DaliException e) {
91208       {
91209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91210       };
91211     } catch (...) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91214       };
91215     }
91216   }
91217
91218 }
91219
91220
91221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91222   unsigned int jresult ;
91223   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91224   bool result;
91225
91226   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91227   {
91228     try {
91229       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);
91230     } catch (std::out_of_range& e) {
91231       {
91232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91233       };
91234     } catch (std::exception& e) {
91235       {
91236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91237       };
91238     } catch (Dali::DaliException e) {
91239       {
91240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91241       };
91242     } catch (...) {
91243       {
91244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91245       };
91246     }
91247   }
91248
91249   jresult = result;
91250   return jresult;
91251 }
91252
91253
91254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91255   unsigned long jresult ;
91256   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91257   std::size_t result;
91258
91259   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91260   {
91261     try {
91262       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);
91263     } catch (std::out_of_range& e) {
91264       {
91265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91266       };
91267     } catch (std::exception& e) {
91268       {
91269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91270       };
91271     } catch (Dali::DaliException e) {
91272       {
91273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91274       };
91275     } catch (...) {
91276       {
91277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91278       };
91279     }
91280   }
91281
91282   jresult = (unsigned long)result;
91283   return jresult;
91284 }
91285
91286
91287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91288   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91289   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91290
91291   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91292   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91293   {
91294     try {
91295       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91296     } catch (std::out_of_range& e) {
91297       {
91298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91299       };
91300     } catch (std::exception& e) {
91301       {
91302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91303       };
91304     } catch (Dali::DaliException e) {
91305       {
91306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91307       };
91308     } catch (...) {
91309       {
91310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91311       };
91312     }
91313   }
91314
91315 }
91316
91317
91318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91319   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91320   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91321
91322   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91323   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91324   {
91325     try {
91326       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91327     } catch (std::out_of_range& e) {
91328       {
91329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91330       };
91331     } catch (std::exception& e) {
91332       {
91333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91334       };
91335     } catch (Dali::DaliException e) {
91336       {
91337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91338       };
91339     } catch (...) {
91340       {
91341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91342       };
91343     }
91344   }
91345
91346 }
91347
91348
91349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91350   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91351   Dali::Toolkit::StyleManager arg2 ;
91352   Dali::StyleChange::Type arg3 ;
91353   Dali::Toolkit::StyleManager *argp2 ;
91354
91355   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91356   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91357   if (!argp2) {
91358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91359     return ;
91360   }
91361   arg2 = *argp2;
91362   arg3 = (Dali::StyleChange::Type)jarg3;
91363   {
91364     try {
91365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91366     } catch (std::out_of_range& e) {
91367       {
91368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91369       };
91370     } catch (std::exception& e) {
91371       {
91372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91373       };
91374     } catch (Dali::DaliException e) {
91375       {
91376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91377       };
91378     } catch (...) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91381       };
91382     }
91383   }
91384
91385 }
91386
91387
91388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91389   void * jresult ;
91390   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91391
91392   {
91393     try {
91394       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91395     } catch (std::out_of_range& e) {
91396       {
91397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91398       };
91399     } catch (std::exception& e) {
91400       {
91401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91402       };
91403     } catch (Dali::DaliException e) {
91404       {
91405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91406       };
91407     } catch (...) {
91408       {
91409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91410       };
91411     }
91412   }
91413
91414   jresult = (void *)result;
91415   return jresult;
91416 }
91417
91418
91419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91420   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91421
91422   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91423   {
91424     try {
91425       delete arg1;
91426     } catch (std::out_of_range& e) {
91427       {
91428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91429       };
91430     } catch (std::exception& e) {
91431       {
91432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91433       };
91434     } catch (Dali::DaliException e) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91437       };
91438     } catch (...) {
91439       {
91440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91441       };
91442     }
91443   }
91444
91445 }
91446
91447
91448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91449   unsigned int jresult ;
91450   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91451   bool result;
91452
91453   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91454   {
91455     try {
91456       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91457     } catch (std::out_of_range& e) {
91458       {
91459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91460       };
91461     } catch (std::exception& e) {
91462       {
91463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91464       };
91465     } catch (Dali::DaliException e) {
91466       {
91467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91468       };
91469     } catch (...) {
91470       {
91471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91472       };
91473     }
91474   }
91475
91476   jresult = result;
91477   return jresult;
91478 }
91479
91480
91481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91482   unsigned long jresult ;
91483   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91484   std::size_t result;
91485
91486   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91487   {
91488     try {
91489       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91490     } catch (std::out_of_range& e) {
91491       {
91492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91493       };
91494     } catch (std::exception& e) {
91495       {
91496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91497       };
91498     } catch (Dali::DaliException e) {
91499       {
91500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91501       };
91502     } catch (...) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91505       };
91506     }
91507   }
91508
91509   jresult = (unsigned long)result;
91510   return jresult;
91511 }
91512
91513
91514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91515   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91516   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91517
91518   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91519   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91520   {
91521     try {
91522       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91523     } catch (std::out_of_range& e) {
91524       {
91525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91526       };
91527     } catch (std::exception& e) {
91528       {
91529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91530       };
91531     } catch (Dali::DaliException e) {
91532       {
91533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91534       };
91535     } catch (...) {
91536       {
91537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91538       };
91539     }
91540   }
91541
91542 }
91543
91544
91545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91546   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91547   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91548
91549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91550   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91551   {
91552     try {
91553       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91554     } catch (std::out_of_range& e) {
91555       {
91556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91557       };
91558     } catch (std::exception& e) {
91559       {
91560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91561       };
91562     } catch (Dali::DaliException e) {
91563       {
91564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91565       };
91566     } catch (...) {
91567       {
91568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91569       };
91570     }
91571   }
91572
91573 }
91574
91575
91576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91577   unsigned int jresult ;
91578   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91579   Dali::Toolkit::Button arg2 ;
91580   Dali::Toolkit::Button *argp2 ;
91581   bool result;
91582
91583   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91584   argp2 = (Dali::Toolkit::Button *)jarg2;
91585   if (!argp2) {
91586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91587     return 0;
91588   }
91589   arg2 = *argp2;
91590   {
91591     try {
91592       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91593     } catch (std::out_of_range& e) {
91594       {
91595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91596       };
91597     } catch (std::exception& e) {
91598       {
91599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91600       };
91601     } catch (Dali::DaliException e) {
91602       {
91603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91604       };
91605     } catch (...) {
91606       {
91607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91608       };
91609     }
91610   }
91611
91612   jresult = result;
91613   return jresult;
91614 }
91615
91616
91617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91618   void * jresult ;
91619   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91620
91621   {
91622     try {
91623       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91624     } catch (std::out_of_range& e) {
91625       {
91626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91627       };
91628     } catch (std::exception& e) {
91629       {
91630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91631       };
91632     } catch (Dali::DaliException e) {
91633       {
91634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91635       };
91636     } catch (...) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91639       };
91640     }
91641   }
91642
91643   jresult = (void *)result;
91644   return jresult;
91645 }
91646
91647
91648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91649   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91650
91651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91652   {
91653     try {
91654       delete arg1;
91655     } catch (std::out_of_range& e) {
91656       {
91657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91658       };
91659     } catch (std::exception& e) {
91660       {
91661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91662       };
91663     } catch (Dali::DaliException e) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91666       };
91667     } catch (...) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91670       };
91671     }
91672   }
91673
91674 }
91675
91676
91677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91678   unsigned int jresult ;
91679   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91680   bool result;
91681
91682   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91683   {
91684     try {
91685       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91686     } catch (std::out_of_range& e) {
91687       {
91688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91689       };
91690     } catch (std::exception& e) {
91691       {
91692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (Dali::DaliException e) {
91695       {
91696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91697       };
91698     } catch (...) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91701       };
91702     }
91703   }
91704
91705   jresult = result;
91706   return jresult;
91707 }
91708
91709
91710 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91711   unsigned long jresult ;
91712   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91713   std::size_t result;
91714
91715   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91716   {
91717     try {
91718       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91719     } catch (std::out_of_range& e) {
91720       {
91721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91722       };
91723     } catch (std::exception& e) {
91724       {
91725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91726       };
91727     } catch (Dali::DaliException e) {
91728       {
91729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91730       };
91731     } catch (...) {
91732       {
91733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91734       };
91735     }
91736   }
91737
91738   jresult = (unsigned long)result;
91739   return jresult;
91740 }
91741
91742
91743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91744   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91745   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91746
91747   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91748   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91749   {
91750     try {
91751       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91752     } catch (std::out_of_range& e) {
91753       {
91754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91755       };
91756     } catch (std::exception& e) {
91757       {
91758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91759       };
91760     } catch (Dali::DaliException e) {
91761       {
91762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91763       };
91764     } catch (...) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91767       };
91768     }
91769   }
91770
91771 }
91772
91773
91774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91775   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91776   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91777
91778   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91779   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91780   {
91781     try {
91782       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91783     } catch (std::out_of_range& e) {
91784       {
91785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91786       };
91787     } catch (std::exception& e) {
91788       {
91789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91790       };
91791     } catch (Dali::DaliException e) {
91792       {
91793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91794       };
91795     } catch (...) {
91796       {
91797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91798       };
91799     }
91800   }
91801
91802 }
91803
91804
91805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91806   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91807   Dali::Toolkit::GaussianBlurView arg2 ;
91808   Dali::Toolkit::GaussianBlurView *argp2 ;
91809
91810   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91811   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91812   if (!argp2) {
91813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91814     return ;
91815   }
91816   arg2 = *argp2;
91817   {
91818     try {
91819       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91820     } catch (std::out_of_range& e) {
91821       {
91822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91823       };
91824     } catch (std::exception& e) {
91825       {
91826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91827       };
91828     } catch (Dali::DaliException e) {
91829       {
91830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91831       };
91832     } catch (...) {
91833       {
91834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91835       };
91836     }
91837   }
91838
91839 }
91840
91841
91842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91843   void * jresult ;
91844   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91845
91846   {
91847     try {
91848       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91849     } catch (std::out_of_range& e) {
91850       {
91851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91852       };
91853     } catch (std::exception& e) {
91854       {
91855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91856       };
91857     } catch (Dali::DaliException e) {
91858       {
91859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91860       };
91861     } catch (...) {
91862       {
91863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91864       };
91865     }
91866   }
91867
91868   jresult = (void *)result;
91869   return jresult;
91870 }
91871
91872
91873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91874   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91875
91876   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91877   {
91878     try {
91879       delete arg1;
91880     } catch (std::out_of_range& e) {
91881       {
91882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91883       };
91884     } catch (std::exception& e) {
91885       {
91886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91887       };
91888     } catch (Dali::DaliException e) {
91889       {
91890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91891       };
91892     } catch (...) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91895       };
91896     }
91897   }
91898
91899 }
91900
91901
91902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91903   unsigned int jresult ;
91904   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91905   bool result;
91906
91907   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91908   {
91909     try {
91910       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);
91911     } catch (std::out_of_range& e) {
91912       {
91913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91914       };
91915     } catch (std::exception& e) {
91916       {
91917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91918       };
91919     } catch (Dali::DaliException e) {
91920       {
91921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91922       };
91923     } catch (...) {
91924       {
91925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91926       };
91927     }
91928   }
91929
91930   jresult = result;
91931   return jresult;
91932 }
91933
91934
91935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91936   unsigned long jresult ;
91937   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91938   std::size_t result;
91939
91940   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91941   {
91942     try {
91943       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);
91944     } catch (std::out_of_range& e) {
91945       {
91946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91947       };
91948     } catch (std::exception& e) {
91949       {
91950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91951       };
91952     } catch (Dali::DaliException e) {
91953       {
91954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91955       };
91956     } catch (...) {
91957       {
91958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91959       };
91960     }
91961   }
91962
91963   jresult = (unsigned long)result;
91964   return jresult;
91965 }
91966
91967
91968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91969   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91970   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91971
91972   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91973   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91974   {
91975     try {
91976       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91977     } catch (std::out_of_range& e) {
91978       {
91979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91980       };
91981     } catch (std::exception& e) {
91982       {
91983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91984       };
91985     } catch (Dali::DaliException e) {
91986       {
91987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91988       };
91989     } catch (...) {
91990       {
91991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91992       };
91993     }
91994   }
91995
91996 }
91997
91998
91999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
92000   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92001   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92002
92003   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92004   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92005   {
92006     try {
92007       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
92008     } catch (std::out_of_range& e) {
92009       {
92010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92011       };
92012     } catch (std::exception& e) {
92013       {
92014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92015       };
92016     } catch (Dali::DaliException e) {
92017       {
92018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92019       };
92020     } catch (...) {
92021       {
92022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92023       };
92024     }
92025   }
92026
92027 }
92028
92029
92030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
92031   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92032   Dali::Toolkit::PageTurnView arg2 ;
92033   unsigned int arg3 ;
92034   bool arg4 ;
92035   Dali::Toolkit::PageTurnView *argp2 ;
92036
92037   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92038   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92039   if (!argp2) {
92040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92041     return ;
92042   }
92043   arg2 = *argp2;
92044   arg3 = (unsigned int)jarg3;
92045   arg4 = jarg4 ? true : false;
92046   {
92047     try {
92048       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92049     } catch (std::out_of_range& e) {
92050       {
92051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92052       };
92053     } catch (std::exception& e) {
92054       {
92055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92056       };
92057     } catch (Dali::DaliException e) {
92058       {
92059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92060       };
92061     } catch (...) {
92062       {
92063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92064       };
92065     }
92066   }
92067
92068 }
92069
92070
92071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
92072   void * jresult ;
92073   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
92074
92075   {
92076     try {
92077       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
92078     } catch (std::out_of_range& e) {
92079       {
92080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92081       };
92082     } catch (std::exception& e) {
92083       {
92084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92085       };
92086     } catch (Dali::DaliException e) {
92087       {
92088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92089       };
92090     } catch (...) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92093       };
92094     }
92095   }
92096
92097   jresult = (void *)result;
92098   return jresult;
92099 }
92100
92101
92102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
92103   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92104
92105   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92106   {
92107     try {
92108       delete arg1;
92109     } catch (std::out_of_range& e) {
92110       {
92111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92112       };
92113     } catch (std::exception& e) {
92114       {
92115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92116       };
92117     } catch (Dali::DaliException e) {
92118       {
92119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92120       };
92121     } catch (...) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92124       };
92125     }
92126   }
92127
92128 }
92129
92130
92131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
92132   unsigned int jresult ;
92133   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92134   bool result;
92135
92136   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92137   {
92138     try {
92139       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92140     } catch (std::out_of_range& e) {
92141       {
92142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92143       };
92144     } catch (std::exception& e) {
92145       {
92146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92147       };
92148     } catch (Dali::DaliException e) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92151       };
92152     } catch (...) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92155       };
92156     }
92157   }
92158
92159   jresult = result;
92160   return jresult;
92161 }
92162
92163
92164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
92165   unsigned long jresult ;
92166   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92167   std::size_t result;
92168
92169   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92170   {
92171     try {
92172       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92173     } catch (std::out_of_range& e) {
92174       {
92175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92176       };
92177     } catch (std::exception& e) {
92178       {
92179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92180       };
92181     } catch (Dali::DaliException e) {
92182       {
92183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92184       };
92185     } catch (...) {
92186       {
92187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92188       };
92189     }
92190   }
92191
92192   jresult = (unsigned long)result;
92193   return jresult;
92194 }
92195
92196
92197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92198   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92199   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92200
92201   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92202   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92203   {
92204     try {
92205       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92206     } catch (std::out_of_range& e) {
92207       {
92208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92209       };
92210     } catch (std::exception& e) {
92211       {
92212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92213       };
92214     } catch (Dali::DaliException e) {
92215       {
92216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92217       };
92218     } catch (...) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92221       };
92222     }
92223   }
92224
92225 }
92226
92227
92228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92229   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92230   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92231
92232   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92233   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92234   {
92235     try {
92236       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92237     } catch (std::out_of_range& e) {
92238       {
92239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92240       };
92241     } catch (std::exception& e) {
92242       {
92243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92244       };
92245     } catch (Dali::DaliException e) {
92246       {
92247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92248       };
92249     } catch (...) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92252       };
92253     }
92254   }
92255
92256 }
92257
92258
92259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92260   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92261   Dali::Toolkit::PageTurnView arg2 ;
92262   Dali::Toolkit::PageTurnView *argp2 ;
92263
92264   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92265   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92266   if (!argp2) {
92267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92268     return ;
92269   }
92270   arg2 = *argp2;
92271   {
92272     try {
92273       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92274     } catch (std::out_of_range& e) {
92275       {
92276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92277       };
92278     } catch (std::exception& e) {
92279       {
92280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92281       };
92282     } catch (Dali::DaliException e) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92285       };
92286     } catch (...) {
92287       {
92288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92289       };
92290     }
92291   }
92292
92293 }
92294
92295
92296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92297   void * jresult ;
92298   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92299
92300   {
92301     try {
92302       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92303     } catch (std::out_of_range& e) {
92304       {
92305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92306       };
92307     } catch (std::exception& e) {
92308       {
92309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92310       };
92311     } catch (Dali::DaliException e) {
92312       {
92313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92314       };
92315     } catch (...) {
92316       {
92317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92318       };
92319     }
92320   }
92321
92322   jresult = (void *)result;
92323   return jresult;
92324 }
92325
92326
92327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92328   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92329
92330   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92331   {
92332     try {
92333       delete arg1;
92334     } catch (std::out_of_range& e) {
92335       {
92336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92337       };
92338     } catch (std::exception& e) {
92339       {
92340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92341       };
92342     } catch (Dali::DaliException e) {
92343       {
92344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92345       };
92346     } catch (...) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92349       };
92350     }
92351   }
92352
92353 }
92354
92355
92356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92357   unsigned int jresult ;
92358   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92359   bool result;
92360
92361   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92362   {
92363     try {
92364       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);
92365     } catch (std::out_of_range& e) {
92366       {
92367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92368       };
92369     } catch (std::exception& e) {
92370       {
92371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92372       };
92373     } catch (Dali::DaliException e) {
92374       {
92375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92376       };
92377     } catch (...) {
92378       {
92379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92380       };
92381     }
92382   }
92383
92384   jresult = result;
92385   return jresult;
92386 }
92387
92388
92389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92390   unsigned long jresult ;
92391   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92392   std::size_t result;
92393
92394   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92395   {
92396     try {
92397       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);
92398     } catch (std::out_of_range& e) {
92399       {
92400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92401       };
92402     } catch (std::exception& e) {
92403       {
92404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92405       };
92406     } catch (Dali::DaliException e) {
92407       {
92408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92409       };
92410     } catch (...) {
92411       {
92412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92413       };
92414     }
92415   }
92416
92417   jresult = (unsigned long)result;
92418   return jresult;
92419 }
92420
92421
92422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92423   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92424   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92425
92426   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92427   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92428   {
92429     try {
92430       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92431     } catch (std::out_of_range& e) {
92432       {
92433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92434       };
92435     } catch (std::exception& e) {
92436       {
92437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92438       };
92439     } catch (Dali::DaliException e) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92442       };
92443     } catch (...) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92446       };
92447     }
92448   }
92449
92450 }
92451
92452
92453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92454   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92455   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92456
92457   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92458   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92459   {
92460     try {
92461       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92462     } catch (std::out_of_range& e) {
92463       {
92464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92465       };
92466     } catch (std::exception& e) {
92467       {
92468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92469       };
92470     } catch (Dali::DaliException e) {
92471       {
92472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92473       };
92474     } catch (...) {
92475       {
92476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92477       };
92478     }
92479   }
92480
92481 }
92482
92483
92484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92485   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92486   Dali::Toolkit::ProgressBar arg2 ;
92487   float arg3 ;
92488   float arg4 ;
92489   Dali::Toolkit::ProgressBar *argp2 ;
92490
92491   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92492   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92493   if (!argp2) {
92494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92495     return ;
92496   }
92497   arg2 = *argp2;
92498   arg3 = (float)jarg3;
92499   arg4 = (float)jarg4;
92500   {
92501     try {
92502       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92503     } catch (std::out_of_range& e) {
92504       {
92505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92506       };
92507     } catch (std::exception& e) {
92508       {
92509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (Dali::DaliException e) {
92512       {
92513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92514       };
92515     } catch (...) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92518       };
92519     }
92520   }
92521
92522 }
92523
92524
92525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92526   void * jresult ;
92527   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92528
92529   {
92530     try {
92531       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92532     } catch (std::out_of_range& e) {
92533       {
92534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92535       };
92536     } catch (std::exception& e) {
92537       {
92538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92539       };
92540     } catch (Dali::DaliException e) {
92541       {
92542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92543       };
92544     } catch (...) {
92545       {
92546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92547       };
92548     }
92549   }
92550
92551   jresult = (void *)result;
92552   return jresult;
92553 }
92554
92555
92556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92557   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92558
92559   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92560   {
92561     try {
92562       delete arg1;
92563     } catch (std::out_of_range& e) {
92564       {
92565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92566       };
92567     } catch (std::exception& e) {
92568       {
92569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92570       };
92571     } catch (Dali::DaliException e) {
92572       {
92573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92574       };
92575     } catch (...) {
92576       {
92577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92578       };
92579     }
92580   }
92581
92582 }
92583
92584
92585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92586   unsigned int jresult ;
92587   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92588   bool result;
92589
92590   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92591   {
92592     try {
92593       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);
92594     } catch (std::out_of_range& e) {
92595       {
92596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92597       };
92598     } catch (std::exception& e) {
92599       {
92600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92601       };
92602     } catch (Dali::DaliException e) {
92603       {
92604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92605       };
92606     } catch (...) {
92607       {
92608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92609       };
92610     }
92611   }
92612
92613   jresult = result;
92614   return jresult;
92615 }
92616
92617
92618 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92619   unsigned long jresult ;
92620   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92621   std::size_t result;
92622
92623   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92624   {
92625     try {
92626       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);
92627     } catch (std::out_of_range& e) {
92628       {
92629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92630       };
92631     } catch (std::exception& e) {
92632       {
92633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92634       };
92635     } catch (Dali::DaliException e) {
92636       {
92637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92638       };
92639     } catch (...) {
92640       {
92641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92642       };
92643     }
92644   }
92645
92646   jresult = (unsigned long)result;
92647   return jresult;
92648 }
92649
92650
92651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92652   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92653   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92654
92655   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92656   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92657   {
92658     try {
92659       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92660     } catch (std::out_of_range& e) {
92661       {
92662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92663       };
92664     } catch (std::exception& e) {
92665       {
92666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92667       };
92668     } catch (Dali::DaliException e) {
92669       {
92670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92671       };
92672     } catch (...) {
92673       {
92674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92675       };
92676     }
92677   }
92678
92679 }
92680
92681
92682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92683   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92684   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92685
92686   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92687   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92688   {
92689     try {
92690       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92691     } catch (std::out_of_range& e) {
92692       {
92693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92694       };
92695     } catch (std::exception& e) {
92696       {
92697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92698       };
92699     } catch (Dali::DaliException e) {
92700       {
92701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92702       };
92703     } catch (...) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92706       };
92707     }
92708   }
92709
92710 }
92711
92712
92713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92714   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92715   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92716
92717   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92718   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92719   if (!arg2) {
92720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92721     return ;
92722   }
92723   {
92724     try {
92725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92741       };
92742     }
92743   }
92744
92745 }
92746
92747
92748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92749   void * jresult ;
92750   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92751
92752   {
92753     try {
92754       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92755     } catch (std::out_of_range& e) {
92756       {
92757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92758       };
92759     } catch (std::exception& e) {
92760       {
92761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92762       };
92763     } catch (Dali::DaliException e) {
92764       {
92765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92766       };
92767     } catch (...) {
92768       {
92769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92770       };
92771     }
92772   }
92773
92774   jresult = (void *)result;
92775   return jresult;
92776 }
92777
92778
92779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92780   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92781
92782   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92783   {
92784     try {
92785       delete arg1;
92786     } catch (std::out_of_range& e) {
92787       {
92788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92789       };
92790     } catch (std::exception& e) {
92791       {
92792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92793       };
92794     } catch (Dali::DaliException e) {
92795       {
92796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92797       };
92798     } catch (...) {
92799       {
92800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92801       };
92802     }
92803   }
92804
92805 }
92806
92807
92808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92809   unsigned int jresult ;
92810   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92811   bool result;
92812
92813   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92814   {
92815     try {
92816       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92817     } catch (std::out_of_range& e) {
92818       {
92819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92820       };
92821     } catch (std::exception& e) {
92822       {
92823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92824       };
92825     } catch (Dali::DaliException e) {
92826       {
92827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92828       };
92829     } catch (...) {
92830       {
92831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92832       };
92833     }
92834   }
92835
92836   jresult = result;
92837   return jresult;
92838 }
92839
92840
92841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92842   unsigned long jresult ;
92843   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92844   std::size_t result;
92845
92846   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92847   {
92848     try {
92849       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92850     } catch (std::out_of_range& e) {
92851       {
92852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92853       };
92854     } catch (std::exception& e) {
92855       {
92856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92857       };
92858     } catch (Dali::DaliException e) {
92859       {
92860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92861       };
92862     } catch (...) {
92863       {
92864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92865       };
92866     }
92867   }
92868
92869   jresult = (unsigned long)result;
92870   return jresult;
92871 }
92872
92873
92874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92875   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92876   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92877
92878   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92879   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92880   {
92881     try {
92882       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92883     } catch (std::out_of_range& e) {
92884       {
92885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92886       };
92887     } catch (std::exception& e) {
92888       {
92889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92890       };
92891     } catch (Dali::DaliException e) {
92892       {
92893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92894       };
92895     } catch (...) {
92896       {
92897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92898       };
92899     }
92900   }
92901
92902 }
92903
92904
92905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92906   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92907   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92908
92909   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92910   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92911   {
92912     try {
92913       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92914     } catch (std::out_of_range& e) {
92915       {
92916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92917       };
92918     } catch (std::exception& e) {
92919       {
92920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92921       };
92922     } catch (Dali::DaliException e) {
92923       {
92924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92925       };
92926     } catch (...) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92929       };
92930     }
92931   }
92932
92933 }
92934
92935
92936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92937   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92938   Dali::Vector2 *arg2 = 0 ;
92939
92940   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92941   arg2 = (Dali::Vector2 *)jarg2;
92942   if (!arg2) {
92943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92944     return ;
92945   }
92946   {
92947     try {
92948       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92949     } catch (std::out_of_range& e) {
92950       {
92951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92952       };
92953     } catch (std::exception& e) {
92954       {
92955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92956       };
92957     } catch (Dali::DaliException e) {
92958       {
92959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92960       };
92961     } catch (...) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92964       };
92965     }
92966   }
92967
92968 }
92969
92970
92971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92972   void * jresult ;
92973   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92974
92975   {
92976     try {
92977       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92993       };
92994     }
92995   }
92996
92997   jresult = (void *)result;
92998   return jresult;
92999 }
93000
93001
93002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
93003   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93004
93005   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93006   {
93007     try {
93008       delete arg1;
93009     } catch (std::out_of_range& e) {
93010       {
93011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (std::exception& e) {
93014       {
93015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93016       };
93017     } catch (Dali::DaliException e) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93020       };
93021     } catch (...) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93024       };
93025     }
93026   }
93027
93028 }
93029
93030
93031
93032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
93033   unsigned int jresult ;
93034   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93035   bool result;
93036
93037   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93038   {
93039     try {
93040       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);
93041     } catch (std::out_of_range& e) {
93042       {
93043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93044       };
93045     } catch (std::exception& e) {
93046       {
93047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93048       };
93049     } catch (Dali::DaliException e) {
93050       {
93051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93052       };
93053     } catch (...) {
93054       {
93055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93056       };
93057     }
93058   }
93059
93060   jresult = result;
93061   return jresult;
93062 }
93063
93064
93065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
93066   unsigned long jresult ;
93067   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93068   std::size_t result;
93069
93070   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93071   {
93072     try {
93073       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);
93074     } catch (std::out_of_range& e) {
93075       {
93076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93077       };
93078     } catch (std::exception& e) {
93079       {
93080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93081       };
93082     } catch (Dali::DaliException e) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93085       };
93086     } catch (...) {
93087       {
93088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93089       };
93090     }
93091   }
93092
93093   jresult = (unsigned long)result;
93094   return jresult;
93095 }
93096
93097
93098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
93099   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93100   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93101
93102   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93103   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93104   {
93105     try {
93106       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93107     } catch (std::out_of_range& e) {
93108       {
93109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93110       };
93111     } catch (std::exception& e) {
93112       {
93113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93114       };
93115     } catch (Dali::DaliException e) {
93116       {
93117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93118       };
93119     } catch (...) {
93120       {
93121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93122       };
93123     }
93124   }
93125
93126 }
93127
93128
93129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
93130   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93131   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93132
93133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93134   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93135   {
93136     try {
93137       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93138     } catch (std::out_of_range& e) {
93139       {
93140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93141       };
93142     } catch (std::exception& e) {
93143       {
93144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93145       };
93146     } catch (Dali::DaliException e) {
93147       {
93148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93149       };
93150     } catch (...) {
93151       {
93152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93153       };
93154     }
93155   }
93156
93157 }
93158
93159
93160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93161   unsigned int jresult ;
93162   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93163   Dali::Toolkit::Control arg2 ;
93164   Dali::KeyEvent *arg3 = 0 ;
93165   Dali::Toolkit::Control *argp2 ;
93166   bool result;
93167
93168   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93169   argp2 = (Dali::Toolkit::Control *)jarg2;
93170   if (!argp2) {
93171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93172     return 0;
93173   }
93174   arg2 = *argp2;
93175   arg3 = (Dali::KeyEvent *)jarg3;
93176   if (!arg3) {
93177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93178     return 0;
93179   }
93180   {
93181     try {
93182       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);
93183     } catch (std::out_of_range& e) {
93184       {
93185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93186       };
93187     } catch (std::exception& e) {
93188       {
93189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93190       };
93191     } catch (Dali::DaliException e) {
93192       {
93193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93194       };
93195     } catch (...) {
93196       {
93197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93198       };
93199     }
93200   }
93201
93202   jresult = result;
93203   return jresult;
93204 }
93205
93206
93207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93208   void * jresult ;
93209   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93210
93211   {
93212     try {
93213       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93214     } catch (std::out_of_range& e) {
93215       {
93216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93217       };
93218     } catch (std::exception& e) {
93219       {
93220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93221       };
93222     } catch (Dali::DaliException e) {
93223       {
93224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93225       };
93226     } catch (...) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93229       };
93230     }
93231   }
93232
93233   jresult = (void *)result;
93234   return jresult;
93235 }
93236
93237
93238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93239   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93240
93241   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93242   {
93243     try {
93244       delete arg1;
93245     } catch (std::out_of_range& e) {
93246       {
93247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93248       };
93249     } catch (std::exception& e) {
93250       {
93251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93252       };
93253     } catch (Dali::DaliException e) {
93254       {
93255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93256       };
93257     } catch (...) {
93258       {
93259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93260       };
93261     }
93262   }
93263
93264 }
93265
93266
93267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93268   unsigned int jresult ;
93269   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93270   bool result;
93271
93272   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93273   {
93274     try {
93275       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93276     } catch (std::out_of_range& e) {
93277       {
93278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93279       };
93280     } catch (std::exception& e) {
93281       {
93282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93283       };
93284     } catch (Dali::DaliException e) {
93285       {
93286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93287       };
93288     } catch (...) {
93289       {
93290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93291       };
93292     }
93293   }
93294
93295   jresult = result;
93296   return jresult;
93297 }
93298
93299
93300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93301   unsigned long jresult ;
93302   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93303   std::size_t result;
93304
93305   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93306   {
93307     try {
93308       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93309     } catch (std::out_of_range& e) {
93310       {
93311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93312       };
93313     } catch (std::exception& e) {
93314       {
93315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93316       };
93317     } catch (Dali::DaliException e) {
93318       {
93319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93320       };
93321     } catch (...) {
93322       {
93323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93324       };
93325     }
93326   }
93327
93328   jresult = (unsigned long)result;
93329   return jresult;
93330 }
93331
93332
93333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93334   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93335   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93336
93337   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93338   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93339   {
93340     try {
93341       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93342     } catch (std::out_of_range& e) {
93343       {
93344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93345       };
93346     } catch (std::exception& e) {
93347       {
93348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93349       };
93350     } catch (Dali::DaliException e) {
93351       {
93352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93353       };
93354     } catch (...) {
93355       {
93356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93357       };
93358     }
93359   }
93360
93361 }
93362
93363
93364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93365   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93366   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93367
93368   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93369   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93370   {
93371     try {
93372       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93373     } catch (std::out_of_range& e) {
93374       {
93375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93376       };
93377     } catch (std::exception& e) {
93378       {
93379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93380       };
93381     } catch (Dali::DaliException e) {
93382       {
93383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93384       };
93385     } catch (...) {
93386       {
93387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93388       };
93389     }
93390   }
93391
93392 }
93393
93394
93395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93396   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93397   Dali::Toolkit::Control arg2 ;
93398   Dali::Toolkit::Control *argp2 ;
93399
93400   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93401   argp2 = (Dali::Toolkit::Control *)jarg2;
93402   if (!argp2) {
93403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93404     return ;
93405   }
93406   arg2 = *argp2;
93407   {
93408     try {
93409       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93410     } catch (std::out_of_range& e) {
93411       {
93412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93413       };
93414     } catch (std::exception& e) {
93415       {
93416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93417       };
93418     } catch (Dali::DaliException e) {
93419       {
93420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93421       };
93422     } catch (...) {
93423       {
93424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93425       };
93426     }
93427   }
93428
93429 }
93430
93431
93432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93433   void * jresult ;
93434   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93435
93436   {
93437     try {
93438       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93439     } catch (std::out_of_range& e) {
93440       {
93441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93442       };
93443     } catch (std::exception& e) {
93444       {
93445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93446       };
93447     } catch (Dali::DaliException e) {
93448       {
93449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93450       };
93451     } catch (...) {
93452       {
93453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93454       };
93455     }
93456   }
93457
93458   jresult = (void *)result;
93459   return jresult;
93460 }
93461
93462
93463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93464   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93465
93466   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93467   {
93468     try {
93469       delete arg1;
93470     } catch (std::out_of_range& e) {
93471       {
93472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93473       };
93474     } catch (std::exception& e) {
93475       {
93476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93477       };
93478     } catch (Dali::DaliException e) {
93479       {
93480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93481       };
93482     } catch (...) {
93483       {
93484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93485       };
93486     }
93487   }
93488
93489 }
93490
93491
93492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93493   unsigned int jresult ;
93494   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93495   bool result;
93496
93497   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93498   {
93499     try {
93500       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93501     } catch (std::out_of_range& e) {
93502       {
93503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93504       };
93505     } catch (std::exception& e) {
93506       {
93507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93508       };
93509     } catch (Dali::DaliException e) {
93510       {
93511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93512       };
93513     } catch (...) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93516       };
93517     }
93518   }
93519
93520   jresult = result;
93521   return jresult;
93522 }
93523
93524
93525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93526   unsigned long jresult ;
93527   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93528   std::size_t result;
93529
93530   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93531   {
93532     try {
93533       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93534     } catch (std::out_of_range& e) {
93535       {
93536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93537       };
93538     } catch (std::exception& e) {
93539       {
93540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93541       };
93542     } catch (Dali::DaliException e) {
93543       {
93544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93545       };
93546     } catch (...) {
93547       {
93548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93549       };
93550     }
93551   }
93552
93553   jresult = (unsigned long)result;
93554   return jresult;
93555 }
93556
93557
93558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93559   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93560   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93561
93562   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93563   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93564   {
93565     try {
93566       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93567     } catch (std::out_of_range& e) {
93568       {
93569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93570       };
93571     } catch (std::exception& e) {
93572       {
93573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93574       };
93575     } catch (Dali::DaliException e) {
93576       {
93577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93578       };
93579     } catch (...) {
93580       {
93581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93582       };
93583     }
93584   }
93585
93586 }
93587
93588
93589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93590   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93591   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93592
93593   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93594   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93595   {
93596     try {
93597       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93598     } catch (std::out_of_range& e) {
93599       {
93600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93601       };
93602     } catch (std::exception& e) {
93603       {
93604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93605       };
93606     } catch (Dali::DaliException e) {
93607       {
93608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93609       };
93610     } catch (...) {
93611       {
93612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93613       };
93614     }
93615   }
93616
93617 }
93618
93619
93620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93621   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93622   Dali::Toolkit::VideoView *arg2 = 0 ;
93623
93624   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93625   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93626   if (!arg2) {
93627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93628     return ;
93629   }
93630   {
93631     try {
93632       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93633     } catch (std::out_of_range& e) {
93634       {
93635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93636       };
93637     } catch (std::exception& e) {
93638       {
93639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93640       };
93641     } catch (Dali::DaliException e) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93644       };
93645     } catch (...) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93648       };
93649     }
93650   }
93651
93652 }
93653
93654
93655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93656   void * jresult ;
93657   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93658
93659   {
93660     try {
93661       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93662     } catch (std::out_of_range& e) {
93663       {
93664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93665       };
93666     } catch (std::exception& e) {
93667       {
93668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93669       };
93670     } catch (Dali::DaliException e) {
93671       {
93672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93673       };
93674     } catch (...) {
93675       {
93676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93677       };
93678     }
93679   }
93680
93681   jresult = (void *)result;
93682   return jresult;
93683 }
93684
93685
93686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93687   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93688
93689   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93690   {
93691     try {
93692       delete arg1;
93693     } catch (std::out_of_range& e) {
93694       {
93695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93696       };
93697     } catch (std::exception& e) {
93698       {
93699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93700       };
93701     } catch (Dali::DaliException e) {
93702       {
93703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93704       };
93705     } catch (...) {
93706       {
93707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93708       };
93709     }
93710   }
93711
93712 }
93713
93714
93715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93716   unsigned int jresult ;
93717   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93718   bool result;
93719
93720   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93721   {
93722     try {
93723       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93724     } catch (std::out_of_range& e) {
93725       {
93726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93727       };
93728     } catch (std::exception& e) {
93729       {
93730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93731       };
93732     } catch (Dali::DaliException e) {
93733       {
93734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93735       };
93736     } catch (...) {
93737       {
93738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93739       };
93740     }
93741   }
93742
93743   jresult = result;
93744   return jresult;
93745 }
93746
93747
93748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93749   unsigned long jresult ;
93750   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93751   std::size_t result;
93752
93753   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93754   {
93755     try {
93756       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93757     } catch (std::out_of_range& e) {
93758       {
93759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93760       };
93761     } catch (std::exception& e) {
93762       {
93763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93764       };
93765     } catch (Dali::DaliException e) {
93766       {
93767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93768       };
93769     } catch (...) {
93770       {
93771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93772       };
93773     }
93774   }
93775
93776   jresult = (unsigned long)result;
93777   return jresult;
93778 }
93779
93780
93781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93782   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93783   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93784
93785   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93786   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93787   {
93788     try {
93789       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93790     } catch (std::out_of_range& e) {
93791       {
93792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93793       };
93794     } catch (std::exception& e) {
93795       {
93796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93797       };
93798     } catch (Dali::DaliException e) {
93799       {
93800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93801       };
93802     } catch (...) {
93803       {
93804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93805       };
93806     }
93807   }
93808
93809 }
93810
93811
93812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93813   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93814   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93815
93816   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93817   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93818   {
93819     try {
93820       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93821     } catch (std::out_of_range& e) {
93822       {
93823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93824       };
93825     } catch (std::exception& e) {
93826       {
93827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93828       };
93829     } catch (Dali::DaliException e) {
93830       {
93831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93832       };
93833     } catch (...) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93836       };
93837     }
93838   }
93839
93840 }
93841
93842
93843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93844   unsigned int jresult ;
93845   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93846   Dali::Toolkit::Slider arg2 ;
93847   float arg3 ;
93848   Dali::Toolkit::Slider *argp2 ;
93849   bool result;
93850
93851   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93852   argp2 = (Dali::Toolkit::Slider *)jarg2;
93853   if (!argp2) {
93854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93855     return 0;
93856   }
93857   arg2 = *argp2;
93858   arg3 = (float)jarg3;
93859   {
93860     try {
93861       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93862     } catch (std::out_of_range& e) {
93863       {
93864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93865       };
93866     } catch (std::exception& e) {
93867       {
93868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93869       };
93870     } catch (Dali::DaliException e) {
93871       {
93872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93873       };
93874     } catch (...) {
93875       {
93876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93877       };
93878     }
93879   }
93880
93881   jresult = result;
93882   return jresult;
93883 }
93884
93885
93886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93887   void * jresult ;
93888   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93889
93890   {
93891     try {
93892       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93893     } catch (std::out_of_range& e) {
93894       {
93895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93896       };
93897     } catch (std::exception& e) {
93898       {
93899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93900       };
93901     } catch (Dali::DaliException e) {
93902       {
93903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93904       };
93905     } catch (...) {
93906       {
93907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93908       };
93909     }
93910   }
93911
93912   jresult = (void *)result;
93913   return jresult;
93914 }
93915
93916
93917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93918   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93919
93920   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93921   {
93922     try {
93923       delete arg1;
93924     } catch (std::out_of_range& e) {
93925       {
93926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93927       };
93928     } catch (std::exception& e) {
93929       {
93930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93931       };
93932     } catch (Dali::DaliException e) {
93933       {
93934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93935       };
93936     } catch (...) {
93937       {
93938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93939       };
93940     }
93941   }
93942
93943 }
93944
93945
93946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93947   unsigned int jresult ;
93948   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93949   bool result;
93950
93951   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93952   {
93953     try {
93954       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93955     } catch (std::out_of_range& e) {
93956       {
93957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93958       };
93959     } catch (std::exception& e) {
93960       {
93961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93962       };
93963     } catch (Dali::DaliException e) {
93964       {
93965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93966       };
93967     } catch (...) {
93968       {
93969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93970       };
93971     }
93972   }
93973
93974   jresult = result;
93975   return jresult;
93976 }
93977
93978
93979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93980   unsigned long jresult ;
93981   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93982   std::size_t result;
93983
93984   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93985   {
93986     try {
93987       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93988     } catch (std::out_of_range& e) {
93989       {
93990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93991       };
93992     } catch (std::exception& e) {
93993       {
93994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93995       };
93996     } catch (Dali::DaliException e) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93999       };
94000     } catch (...) {
94001       {
94002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94003       };
94004     }
94005   }
94006
94007   jresult = (unsigned long)result;
94008   return jresult;
94009 }
94010
94011
94012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
94013   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94014   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94015
94016   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94017   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94018   {
94019     try {
94020       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
94021     } catch (std::out_of_range& e) {
94022       {
94023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94024       };
94025     } catch (std::exception& e) {
94026       {
94027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94028       };
94029     } catch (Dali::DaliException e) {
94030       {
94031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94032       };
94033     } catch (...) {
94034       {
94035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94036       };
94037     }
94038   }
94039
94040 }
94041
94042
94043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
94044   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94045   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94046
94047   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94048   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94049   {
94050     try {
94051       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
94052     } catch (std::out_of_range& e) {
94053       {
94054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (std::exception& e) {
94057       {
94058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94059       };
94060     } catch (Dali::DaliException e) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94063       };
94064     } catch (...) {
94065       {
94066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94067       };
94068     }
94069   }
94070
94071 }
94072
94073
94074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94075   unsigned int jresult ;
94076   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94077   Dali::Toolkit::Slider arg2 ;
94078   int arg3 ;
94079   Dali::Toolkit::Slider *argp2 ;
94080   bool result;
94081
94082   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94083   argp2 = (Dali::Toolkit::Slider *)jarg2;
94084   if (!argp2) {
94085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
94086     return 0;
94087   }
94088   arg2 = *argp2;
94089   arg3 = (int)jarg3;
94090   {
94091     try {
94092       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
94093     } catch (std::out_of_range& e) {
94094       {
94095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94096       };
94097     } catch (std::exception& e) {
94098       {
94099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94100       };
94101     } catch (Dali::DaliException e) {
94102       {
94103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94104       };
94105     } catch (...) {
94106       {
94107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94108       };
94109     }
94110   }
94111
94112   jresult = result;
94113   return jresult;
94114 }
94115
94116
94117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
94118   void * jresult ;
94119   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
94120
94121   {
94122     try {
94123       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
94124     } catch (std::out_of_range& e) {
94125       {
94126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94127       };
94128     } catch (std::exception& e) {
94129       {
94130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94131       };
94132     } catch (Dali::DaliException e) {
94133       {
94134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94135       };
94136     } catch (...) {
94137       {
94138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94139       };
94140     }
94141   }
94142
94143   jresult = (void *)result;
94144   return jresult;
94145 }
94146
94147
94148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
94149   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94150
94151   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94152   {
94153     try {
94154       delete arg1;
94155     } catch (std::out_of_range& e) {
94156       {
94157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94158       };
94159     } catch (std::exception& e) {
94160       {
94161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94162       };
94163     } catch (Dali::DaliException e) {
94164       {
94165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94166       };
94167     } catch (...) {
94168       {
94169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94170       };
94171     }
94172   }
94173
94174 }
94175
94176
94177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94178   void * jresult ;
94179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94180
94181   {
94182     try {
94183       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94184     } catch (std::out_of_range& e) {
94185       {
94186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94187       };
94188     } catch (std::exception& e) {
94189       {
94190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94191       };
94192     } catch (Dali::DaliException e) {
94193       {
94194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94195       };
94196     } catch (...) {
94197       {
94198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94199       };
94200     }
94201   }
94202
94203   jresult = (void *)result;
94204   return jresult;
94205 }
94206
94207
94208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94209   void * jresult ;
94210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94212
94213   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94214   {
94215     try {
94216       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94217     } catch (std::out_of_range& e) {
94218       {
94219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94220       };
94221     } catch (std::exception& e) {
94222       {
94223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94224       };
94225     } catch (Dali::DaliException e) {
94226       {
94227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94228       };
94229     } catch (...) {
94230       {
94231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94232       };
94233     }
94234   }
94235
94236   jresult = (void *)result;
94237   return jresult;
94238 }
94239
94240
94241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94242   void * jresult ;
94243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94245
94246   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94247   if (!arg1) {
94248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94249     return 0;
94250   }
94251   {
94252     try {
94253       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94254     } catch (std::out_of_range& e) {
94255       {
94256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94257       };
94258     } catch (std::exception& e) {
94259       {
94260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94261       };
94262     } catch (Dali::DaliException e) {
94263       {
94264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94265       };
94266     } catch (...) {
94267       {
94268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94269       };
94270     }
94271   }
94272
94273   jresult = (void *)result;
94274   return jresult;
94275 }
94276
94277
94278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94280
94281   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94282   {
94283     try {
94284       delete arg1;
94285     } catch (std::out_of_range& e) {
94286       {
94287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94288       };
94289     } catch (std::exception& e) {
94290       {
94291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94292       };
94293     } catch (Dali::DaliException e) {
94294       {
94295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94296       };
94297     } catch (...) {
94298       {
94299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94300       };
94301     }
94302   }
94303
94304 }
94305
94306
94307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94308   void * jresult ;
94309   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94310   Dali::Toolkit::Ruler *result = 0 ;
94311
94312   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94313   {
94314     try {
94315       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94316     } catch (std::out_of_range& e) {
94317       {
94318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94319       };
94320     } catch (std::exception& e) {
94321       {
94322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94323       };
94324     } catch (Dali::DaliException e) {
94325       {
94326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94327       };
94328     } catch (...) {
94329       {
94330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94331       };
94332     }
94333   }
94334
94335   jresult = (void *)result;
94336   return jresult;
94337 }
94338
94339
94340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94341   void * jresult ;
94342   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94343   Dali::Toolkit::Ruler *result = 0 ;
94344
94345   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94346   {
94347     try {
94348       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94349     } catch (std::out_of_range& e) {
94350       {
94351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94352       };
94353     } catch (std::exception& e) {
94354       {
94355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94356       };
94357     } catch (Dali::DaliException e) {
94358       {
94359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94360       };
94361     } catch (...) {
94362       {
94363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94364       };
94365     }
94366   }
94367
94368   jresult = (void *)result;
94369   return jresult;
94370 }
94371
94372
94373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94374   void * jresult ;
94375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94376   Dali::Toolkit::Ruler *result = 0 ;
94377
94378   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94379   {
94380     try {
94381       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94382     } catch (std::out_of_range& e) {
94383       {
94384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94385       };
94386     } catch (std::exception& e) {
94387       {
94388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94389       };
94390     } catch (Dali::DaliException e) {
94391       {
94392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94393       };
94394     } catch (...) {
94395       {
94396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94397       };
94398     }
94399   }
94400
94401   jresult = (void *)result;
94402   return jresult;
94403 }
94404
94405
94406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94407   void * jresult ;
94408   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94409   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94410   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94411
94412   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94413   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94414   if (!arg2) {
94415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94416     return 0;
94417   }
94418   {
94419     try {
94420       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94421     } catch (std::out_of_range& e) {
94422       {
94423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94424       };
94425     } catch (std::exception& e) {
94426       {
94427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94428       };
94429     } catch (Dali::DaliException e) {
94430       {
94431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94432       };
94433     } catch (...) {
94434       {
94435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94436       };
94437     }
94438   }
94439
94440   jresult = (void *)result;
94441   return jresult;
94442 }
94443
94444
94445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94446   void * jresult ;
94447   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94448   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94450
94451   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94452   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94453   {
94454     try {
94455       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94456     } catch (std::out_of_range& e) {
94457       {
94458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94459       };
94460     } catch (std::exception& e) {
94461       {
94462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94463       };
94464     } catch (Dali::DaliException e) {
94465       {
94466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94467       };
94468     } catch (...) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94471       };
94472     }
94473   }
94474
94475   jresult = (void *)result;
94476   return jresult;
94477 }
94478
94479
94480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94481   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94482
94483   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94484   {
94485     try {
94486       (arg1)->Reset();
94487     } catch (std::out_of_range& e) {
94488       {
94489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94490       };
94491     } catch (std::exception& e) {
94492       {
94493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94494       };
94495     } catch (Dali::DaliException e) {
94496       {
94497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94498       };
94499     } catch (...) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94502       };
94503     }
94504   }
94505
94506 }
94507
94508
94509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94511   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94512
94513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94514   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94515   {
94516     try {
94517       (arg1)->Reset(arg2);
94518     } catch (std::out_of_range& e) {
94519       {
94520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94521       };
94522     } catch (std::exception& e) {
94523       {
94524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (Dali::DaliException e) {
94527       {
94528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94529       };
94530     } catch (...) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94533       };
94534     }
94535   }
94536
94537 }
94538
94539
94540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94541   void * jresult ;
94542   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94543   Dali::Toolkit::Ruler *result = 0 ;
94544
94545   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94546   {
94547     try {
94548       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94549     } catch (std::out_of_range& e) {
94550       {
94551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94552       };
94553     } catch (std::exception& e) {
94554       {
94555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94556       };
94557     } catch (Dali::DaliException e) {
94558       {
94559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94560       };
94561     } catch (...) {
94562       {
94563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94564       };
94565     }
94566   }
94567
94568   jresult = (void *)result;
94569   return jresult;
94570 }
94571
94572
94573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94574   float jresult ;
94575   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94576   float arg2 ;
94577   float arg3 ;
94578   float result;
94579
94580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94581   arg2 = (float)jarg2;
94582   arg3 = (float)jarg3;
94583   {
94584     try {
94585       result = (float)(*arg1)->Snap(arg2,arg3);
94586     } catch (std::out_of_range& e) {
94587       {
94588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94589       };
94590     } catch (std::exception& e) {
94591       {
94592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94593       };
94594     } catch (Dali::DaliException e) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94597       };
94598     } catch (...) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94601       };
94602     }
94603   }
94604
94605   jresult = result;
94606   return jresult;
94607 }
94608
94609
94610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94611   float jresult ;
94612   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94613   float arg2 ;
94614   float result;
94615
94616   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94617   arg2 = (float)jarg2;
94618   {
94619     try {
94620       result = (float)(*arg1)->Snap(arg2);
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94636       };
94637     }
94638   }
94639
94640   jresult = result;
94641   return jresult;
94642 }
94643
94644
94645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94646   float jresult ;
94647   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94648   unsigned int arg2 ;
94649   unsigned int *arg3 = 0 ;
94650   bool arg4 ;
94651   float result;
94652
94653   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94654   arg2 = (unsigned int)jarg2;
94655   arg3 = (unsigned int *)jarg3;
94656   arg4 = jarg4 ? true : false;
94657   {
94658     try {
94659       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94660     } catch (std::out_of_range& e) {
94661       {
94662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94663       };
94664     } catch (std::exception& e) {
94665       {
94666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94667       };
94668     } catch (Dali::DaliException e) {
94669       {
94670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94671       };
94672     } catch (...) {
94673       {
94674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94675       };
94676     }
94677   }
94678
94679   jresult = result;
94680   return jresult;
94681 }
94682
94683
94684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94685   unsigned int jresult ;
94686   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94687   float arg2 ;
94688   bool arg3 ;
94689   unsigned int result;
94690
94691   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94692   arg2 = (float)jarg2;
94693   arg3 = jarg3 ? true : false;
94694   {
94695     try {
94696       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94697     } catch (std::out_of_range& e) {
94698       {
94699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94700       };
94701     } catch (std::exception& e) {
94702       {
94703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94704       };
94705     } catch (Dali::DaliException e) {
94706       {
94707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94708       };
94709     } catch (...) {
94710       {
94711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94712       };
94713     }
94714   }
94715
94716   jresult = result;
94717   return jresult;
94718 }
94719
94720
94721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94722   unsigned int jresult ;
94723   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94724   unsigned int result;
94725
94726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94727   {
94728     try {
94729       result = (unsigned int)(*arg1)->GetTotalPages();
94730     } catch (std::out_of_range& e) {
94731       {
94732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94733       };
94734     } catch (std::exception& e) {
94735       {
94736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94737       };
94738     } catch (Dali::DaliException e) {
94739       {
94740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94741       };
94742     } catch (...) {
94743       {
94744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94745       };
94746     }
94747   }
94748
94749   jresult = result;
94750   return jresult;
94751 }
94752
94753
94754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94755   int jresult ;
94756   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94757   Dali::Toolkit::Ruler::RulerType result;
94758
94759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94760   {
94761     try {
94762       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94763     } catch (std::out_of_range& e) {
94764       {
94765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94766       };
94767     } catch (std::exception& e) {
94768       {
94769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94770       };
94771     } catch (Dali::DaliException e) {
94772       {
94773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94774       };
94775     } catch (...) {
94776       {
94777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94778       };
94779     }
94780   }
94781
94782   jresult = (int)result;
94783   return jresult;
94784 }
94785
94786
94787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94788   unsigned int jresult ;
94789   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94790   bool result;
94791
94792   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94793   {
94794     try {
94795       result = (bool)(*arg1)->IsEnabled();
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 void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94821   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94822
94823   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94824   {
94825     try {
94826       (*arg1)->Enable();
94827     } catch (std::out_of_range& e) {
94828       {
94829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94830       };
94831     } catch (std::exception& e) {
94832       {
94833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94834       };
94835     } catch (Dali::DaliException e) {
94836       {
94837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94838       };
94839     } catch (...) {
94840       {
94841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94842       };
94843     }
94844   }
94845
94846 }
94847
94848
94849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94851
94852   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94853   {
94854     try {
94855       (*arg1)->Disable();
94856     } catch (std::out_of_range& e) {
94857       {
94858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94859       };
94860     } catch (std::exception& e) {
94861       {
94862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94863       };
94864     } catch (Dali::DaliException e) {
94865       {
94866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94867       };
94868     } catch (...) {
94869       {
94870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94871       };
94872     }
94873   }
94874
94875 }
94876
94877
94878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94879   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94880   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94881   Dali::Toolkit::RulerDomain *argp2 ;
94882
94883   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94884   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94885   if (!argp2) {
94886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94887     return ;
94888   }
94889   arg2 = *argp2;
94890   {
94891     try {
94892       (*arg1)->SetDomain(arg2);
94893     } catch (std::out_of_range& e) {
94894       {
94895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94896       };
94897     } catch (std::exception& e) {
94898       {
94899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94900       };
94901     } catch (Dali::DaliException e) {
94902       {
94903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94904       };
94905     } catch (...) {
94906       {
94907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94908       };
94909     }
94910   }
94911
94912 }
94913
94914
94915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94916   void * jresult ;
94917   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94918   Dali::Toolkit::RulerDomain *result = 0 ;
94919
94920   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94921   {
94922     try {
94923       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94924     } catch (std::out_of_range& e) {
94925       {
94926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94927       };
94928     } catch (std::exception& e) {
94929       {
94930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94931       };
94932     } catch (Dali::DaliException e) {
94933       {
94934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94935       };
94936     } catch (...) {
94937       {
94938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94939       };
94940     }
94941   }
94942
94943   jresult = (void *)result;
94944   return jresult;
94945 }
94946
94947
94948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94949   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94950
94951   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94952   {
94953     try {
94954       (*arg1)->DisableDomain();
94955     } catch (std::out_of_range& e) {
94956       {
94957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94958       };
94959     } catch (std::exception& e) {
94960       {
94961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94962       };
94963     } catch (Dali::DaliException e) {
94964       {
94965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94966       };
94967     } catch (...) {
94968       {
94969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94970       };
94971     }
94972   }
94973
94974 }
94975
94976
94977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94978   float jresult ;
94979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94980   float arg2 ;
94981   float arg3 ;
94982   float arg4 ;
94983   float result;
94984
94985   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94986   arg2 = (float)jarg2;
94987   arg3 = (float)jarg3;
94988   arg4 = (float)jarg4;
94989   {
94990     try {
94991       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94992     } catch (std::out_of_range& e) {
94993       {
94994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94995       };
94996     } catch (std::exception& e) {
94997       {
94998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94999       };
95000     } catch (Dali::DaliException e) {
95001       {
95002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95003       };
95004     } catch (...) {
95005       {
95006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95007       };
95008     }
95009   }
95010
95011   jresult = result;
95012   return jresult;
95013 }
95014
95015
95016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
95017   float jresult ;
95018   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95019   float arg2 ;
95020   float arg3 ;
95021   float result;
95022
95023   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95024   arg2 = (float)jarg2;
95025   arg3 = (float)jarg3;
95026   {
95027     try {
95028       result = (float)(*arg1)->Clamp(arg2,arg3);
95029     } catch (std::out_of_range& e) {
95030       {
95031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95032       };
95033     } catch (std::exception& e) {
95034       {
95035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95036       };
95037     } catch (Dali::DaliException e) {
95038       {
95039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95040       };
95041     } catch (...) {
95042       {
95043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95044       };
95045     }
95046   }
95047
95048   jresult = result;
95049   return jresult;
95050 }
95051
95052
95053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
95054   float jresult ;
95055   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95056   float arg2 ;
95057   float result;
95058
95059   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95060   arg2 = (float)jarg2;
95061   {
95062     try {
95063       result = (float)(*arg1)->Clamp(arg2);
95064     } catch (std::out_of_range& e) {
95065       {
95066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95067       };
95068     } catch (std::exception& e) {
95069       {
95070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95071       };
95072     } catch (Dali::DaliException e) {
95073       {
95074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95075       };
95076     } catch (...) {
95077       {
95078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95079       };
95080     }
95081   }
95082
95083   jresult = result;
95084   return jresult;
95085 }
95086
95087
95088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
95089   float jresult ;
95090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95091   float arg2 ;
95092   float arg3 ;
95093   float arg4 ;
95094   Dali::Toolkit::ClampState *arg5 = 0 ;
95095   float result;
95096
95097   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95098   arg2 = (float)jarg2;
95099   arg3 = (float)jarg3;
95100   arg4 = (float)jarg4;
95101   arg5 = (Dali::Toolkit::ClampState *)jarg5;
95102   if (!arg5) {
95103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95104     return 0;
95105   }
95106   {
95107     try {
95108       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
95109     } catch (std::out_of_range& e) {
95110       {
95111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95112       };
95113     } catch (std::exception& e) {
95114       {
95115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95116       };
95117     } catch (Dali::DaliException e) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95120       };
95121     } catch (...) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95124       };
95125     }
95126   }
95127
95128   jresult = result;
95129   return jresult;
95130 }
95131
95132
95133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
95134   float jresult ;
95135   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95136   float arg2 ;
95137   float arg3 ;
95138   float arg4 ;
95139   float arg5 ;
95140   float result;
95141
95142   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95143   arg2 = (float)jarg2;
95144   arg3 = (float)jarg3;
95145   arg4 = (float)jarg4;
95146   arg5 = (float)jarg5;
95147   {
95148     try {
95149       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
95150     } catch (std::out_of_range& e) {
95151       {
95152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95153       };
95154     } catch (std::exception& e) {
95155       {
95156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95157       };
95158     } catch (Dali::DaliException e) {
95159       {
95160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95161       };
95162     } catch (...) {
95163       {
95164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95165       };
95166     }
95167   }
95168
95169   jresult = result;
95170   return jresult;
95171 }
95172
95173
95174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
95175   float jresult ;
95176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95177   float arg2 ;
95178   float arg3 ;
95179   float arg4 ;
95180   float result;
95181
95182   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95183   arg2 = (float)jarg2;
95184   arg3 = (float)jarg3;
95185   arg4 = (float)jarg4;
95186   {
95187     try {
95188       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95189     } catch (std::out_of_range& e) {
95190       {
95191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95192       };
95193     } catch (std::exception& e) {
95194       {
95195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95196       };
95197     } catch (Dali::DaliException e) {
95198       {
95199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95200       };
95201     } catch (...) {
95202       {
95203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95204       };
95205     }
95206   }
95207
95208   jresult = result;
95209   return jresult;
95210 }
95211
95212
95213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95214   float jresult ;
95215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95216   float arg2 ;
95217   float arg3 ;
95218   float result;
95219
95220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95221   arg2 = (float)jarg2;
95222   arg3 = (float)jarg3;
95223   {
95224     try {
95225       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95226     } catch (std::out_of_range& e) {
95227       {
95228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95229       };
95230     } catch (std::exception& e) {
95231       {
95232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95233       };
95234     } catch (Dali::DaliException e) {
95235       {
95236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95237       };
95238     } catch (...) {
95239       {
95240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95241       };
95242     }
95243   }
95244
95245   jresult = result;
95246   return jresult;
95247 }
95248
95249
95250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95251   float jresult ;
95252   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95253   float arg2 ;
95254   float result;
95255
95256   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95257   arg2 = (float)jarg2;
95258   {
95259     try {
95260       result = (float)(*arg1)->SnapAndClamp(arg2);
95261     } catch (std::out_of_range& e) {
95262       {
95263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95264       };
95265     } catch (std::exception& e) {
95266       {
95267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95268       };
95269     } catch (Dali::DaliException e) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95272       };
95273     } catch (...) {
95274       {
95275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95276       };
95277     }
95278   }
95279
95280   jresult = result;
95281   return jresult;
95282 }
95283
95284
95285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95286   float jresult ;
95287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95288   float arg2 ;
95289   float arg3 ;
95290   float arg4 ;
95291   float arg5 ;
95292   Dali::Toolkit::ClampState *arg6 = 0 ;
95293   float result;
95294
95295   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95296   arg2 = (float)jarg2;
95297   arg3 = (float)jarg3;
95298   arg4 = (float)jarg4;
95299   arg5 = (float)jarg5;
95300   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95301   if (!arg6) {
95302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95303     return 0;
95304   }
95305   {
95306     try {
95307       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95308     } catch (std::out_of_range& e) {
95309       {
95310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95311       };
95312     } catch (std::exception& e) {
95313       {
95314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95315       };
95316     } catch (Dali::DaliException e) {
95317       {
95318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95319       };
95320     } catch (...) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95323       };
95324     }
95325   }
95326
95327   jresult = result;
95328   return jresult;
95329 }
95330
95331
95332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95333   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95334
95335   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95336   {
95337     try {
95338       (*arg1)->Reference();
95339     } catch (std::out_of_range& e) {
95340       {
95341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95342       };
95343     } catch (std::exception& e) {
95344       {
95345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95346       };
95347     } catch (Dali::DaliException e) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95350       };
95351     } catch (...) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95354       };
95355     }
95356   }
95357
95358 }
95359
95360
95361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95362   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95363
95364   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95365   {
95366     try {
95367       (*arg1)->Unreference();
95368     } catch (std::out_of_range& e) {
95369       {
95370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (std::exception& e) {
95373       {
95374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95375       };
95376     } catch (Dali::DaliException e) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95379       };
95380     } catch (...) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95383       };
95384     }
95385   }
95386
95387 }
95388
95389
95390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95391   int jresult ;
95392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95393   int result;
95394
95395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95396   {
95397     try {
95398       result = (int)(*arg1)->ReferenceCount();
95399     } catch (std::out_of_range& e) {
95400       {
95401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95402       };
95403     } catch (std::exception& e) {
95404       {
95405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95406       };
95407     } catch (Dali::DaliException e) {
95408       {
95409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95410       };
95411     } catch (...) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95414       };
95415     }
95416   }
95417
95418   jresult = result;
95419   return jresult;
95420 }
95421
95422
95423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95424   unsigned int jresult ;
95425   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95426   bool result;
95427
95428   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95429   {
95430     try {
95431       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95432     } catch (std::out_of_range& e) {
95433       {
95434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95435       };
95436     } catch (std::exception& e) {
95437       {
95438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95439       };
95440     } catch (Dali::DaliException e) {
95441       {
95442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95443       };
95444     } catch (...) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95447       };
95448     }
95449   }
95450
95451   jresult = result;
95452   return jresult;
95453 }
95454
95455
95456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95457   unsigned long jresult ;
95458   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95459   std::size_t result;
95460
95461   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95462   {
95463     try {
95464       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95465     } catch (std::out_of_range& e) {
95466       {
95467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95468       };
95469     } catch (std::exception& e) {
95470       {
95471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95472       };
95473     } catch (Dali::DaliException e) {
95474       {
95475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95476       };
95477     } catch (...) {
95478       {
95479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95480       };
95481     }
95482   }
95483
95484   jresult = (unsigned long)result;
95485   return jresult;
95486 }
95487
95488
95489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95490   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95491   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95492
95493   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95494   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95495   {
95496     try {
95497       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95498     } catch (std::out_of_range& e) {
95499       {
95500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95501       };
95502     } catch (std::exception& e) {
95503       {
95504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95505       };
95506     } catch (Dali::DaliException e) {
95507       {
95508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95509       };
95510     } catch (...) {
95511       {
95512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95513       };
95514     }
95515   }
95516
95517 }
95518
95519
95520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95521   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95522   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95523
95524   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95525   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95526   {
95527     try {
95528       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95529     } catch (std::out_of_range& e) {
95530       {
95531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95532       };
95533     } catch (std::exception& e) {
95534       {
95535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95536       };
95537     } catch (Dali::DaliException e) {
95538       {
95539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95540       };
95541     } catch (...) {
95542       {
95543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95544       };
95545     }
95546   }
95547
95548 }
95549
95550
95551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95552   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95553   Dali::Toolkit::Control arg2 ;
95554   Dali::Toolkit::Control *argp2 ;
95555
95556   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95557   argp2 = (Dali::Toolkit::Control *)jarg2;
95558   if (!argp2) {
95559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95560     return ;
95561   }
95562   arg2 = *argp2;
95563   {
95564     try {
95565       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95566     } catch (std::out_of_range& e) {
95567       {
95568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95569       };
95570     } catch (std::exception& e) {
95571       {
95572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95573       };
95574     } catch (Dali::DaliException e) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95577       };
95578     } catch (...) {
95579       {
95580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95581       };
95582     }
95583   }
95584
95585 }
95586
95587
95588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95589   void * jresult ;
95590   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95591
95592   {
95593     try {
95594       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95595     } catch (std::out_of_range& e) {
95596       {
95597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95598       };
95599     } catch (std::exception& e) {
95600       {
95601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95602       };
95603     } catch (Dali::DaliException e) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95606       };
95607     } catch (...) {
95608       {
95609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95610       };
95611     }
95612   }
95613
95614   jresult = (void *)result;
95615   return jresult;
95616 }
95617
95618
95619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95620   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95621
95622   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95623   {
95624     try {
95625       delete arg1;
95626     } catch (std::out_of_range& e) {
95627       {
95628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95629       };
95630     } catch (std::exception& e) {
95631       {
95632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95633       };
95634     } catch (Dali::DaliException e) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95641       };
95642     }
95643   }
95644
95645 }
95646
95647 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95648   Dali::RefObject *result = NULL;
95649
95650   if (arg1)
95651   {
95652     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95653   }
95654   return result;
95655 }
95656
95657 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95658     return (Dali::RefObject *)jarg1;
95659 }
95660
95661 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95662     return (Dali::SignalObserver *)jarg1;
95663 }
95664
95665 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95666     return (Dali::ConnectionTrackerInterface *)jarg1;
95667 }
95668
95669 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95670     return (Dali::BaseHandle *)jarg1;
95671 }
95672
95673 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95674     return (Dali::BaseHandle *)jarg1;
95675 }
95676
95677 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95678     return (Dali::BaseHandle *)jarg1;
95679 }
95680
95681 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95682     return (Dali::BaseHandle *)jarg1;
95683 }
95684
95685 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95686     return (Dali::BaseHandle *)jarg1;
95687 }
95688
95689 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95690     return (Dali::BaseHandle *)jarg1;
95691 }
95692
95693 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95694     return (Dali::BaseHandle *)jarg1;
95695 }
95696
95697 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95698     return (Dali::BaseHandle *)jarg1;
95699 }
95700
95701 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95702     return (Dali::BaseHandle *)jarg1;
95703 }
95704
95705 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95706     return (Dali::BaseHandle *)jarg1;
95707 }
95708
95709 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
95710     return (Dali::BaseHandle *)jarg1;
95711 }
95712
95713 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95714     return (Dali::BaseHandle *)jarg1;
95715 }
95716
95717 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95718     return (Dali::Handle *)jarg1;
95719 }
95720
95721 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95722     return (Dali::Handle *)jarg1;
95723 }
95724
95725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95726     return (Dali::BaseHandle *)jarg1;
95727 }
95728
95729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95730     return (Dali::BaseHandle *)jarg1;
95731 }
95732
95733 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95734     return (Dali::Handle *)jarg1;
95735 }
95736
95737 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95738     return (Dali::BaseHandle *)jarg1;
95739 }
95740
95741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95742     return (Dali::BaseHandle *)jarg1;
95743 }
95744
95745 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
95746     return (Dali::BaseHandle *)jarg1;
95747 }
95748
95749 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
95750     return (Dali::BaseHandle *)jarg1;
95751 }
95752
95753 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95754     return (Dali::Handle *)jarg1;
95755 }
95756
95757 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95758     return (Dali::GestureDetector *)jarg1;
95759 }
95760
95761 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95762     return (Dali::Gesture *)jarg1;
95763 }
95764
95765 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95766     return (Dali::Handle *)jarg1;
95767 }
95768
95769 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95770     return (Dali::Actor *)jarg1;
95771 }
95772
95773 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95774     return (Dali::RefObject *)jarg1;
95775 }
95776
95777 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95778     return (Dali::Actor *)jarg1;
95779 }
95780
95781 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95782     return (Dali::GestureDetector *)jarg1;
95783 }
95784
95785 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95786     return (Dali::Gesture *)jarg1;
95787 }
95788
95789 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95790     return (Dali::GestureDetector *)jarg1;
95791 }
95792
95793 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95794     return (Dali::Gesture *)jarg1;
95795 }
95796
95797 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95798     return (Dali::GestureDetector *)jarg1;
95799 }
95800
95801 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95802     return (Dali::Gesture *)jarg1;
95803 }
95804
95805 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95806     return (Dali::BaseHandle *)jarg1;
95807 }
95808
95809 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95810     return (Dali::Handle *)jarg1;
95811 }
95812
95813 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95814     return (Dali::Handle *)jarg1;
95815 }
95816
95817 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95818     return (Dali::Handle *)jarg1;
95819 }
95820
95821 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95822     return (Dali::RefObject *)jarg1;
95823 }
95824
95825 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95826     return (Dali::Actor *)jarg1;
95827 }
95828
95829 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95830     return (Dali::BaseHandle *)jarg1;
95831 }
95832
95833 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95834     return (Dali::BaseHandle *)jarg1;
95835 }
95836
95837 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95838     return (Dali::BaseHandle *)jarg1;
95839 }
95840
95841 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95842     return (Dali::CustomActorImpl *)jarg1;
95843 }
95844
95845 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95846     return (Dali::CustomActor *)jarg1;
95847 }
95848
95849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95850     return (Dali::BaseHandle *)jarg1;
95851 }
95852
95853 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95854     return (Dali::Toolkit::Control *)jarg1;
95855 }
95856
95857 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95858     return (Dali::Toolkit::Control *)jarg1;
95859 }
95860
95861 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95862     return (Dali::Toolkit::Button *)jarg1;
95863 }
95864
95865 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95866     return (Dali::Toolkit::Button *)jarg1;
95867 }
95868
95869 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95870     return (Dali::Toolkit::Button *)jarg1;
95871 }
95872
95873 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95874     return (Dali::Toolkit::Control *)jarg1;
95875 }
95876
95877 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95878     return (Dali::Toolkit::Control *)jarg1;
95879 }
95880
95881 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95882     return (Dali::Toolkit::Control *)jarg1;
95883 }
95884
95885 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95886     return (Dali::Toolkit::Control *)jarg1;
95887 }
95888
95889 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95890     return (Dali::Toolkit::Control *)jarg1;
95891 }
95892
95893 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95894     return (Dali::RefObject *)jarg1;
95895 }
95896
95897 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95898     return (Dali::Toolkit::Scrollable *)jarg1;
95899 }
95900
95901 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95902     return (Dali::BaseHandle *)jarg1;
95903 }
95904
95905 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95906     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95907 }
95908
95909 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95910     return (Dali::RefObject *)jarg1;
95911 }
95912
95913 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95914     return (Dali::Toolkit::Ruler *)jarg1;
95915 }
95916
95917 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95918     return (Dali::Toolkit::Ruler *)jarg1;
95919 }
95920
95921 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95922     return (Dali::Toolkit::Scrollable *)jarg1;
95923 }
95924
95925 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95926     return (Dali::Toolkit::Control *)jarg1;
95927 }
95928
95929
95930 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95931     return (Dali::Toolkit::Control *)jarg1;
95932 }
95933
95934 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95935     return (Dali::BaseHandle *)jarg1;
95936 }
95937
95938 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95939     return (Dali::BaseHandle *)jarg1;
95940 }
95941
95942 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95943     return (Dali::Toolkit::Control *)jarg1;
95944 }
95945
95946 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95947     return (Dali::Toolkit::Control *)jarg1;
95948 }
95949
95950 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95951     return (Dali::Toolkit::Control *)jarg1;
95952 }
95953
95954 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95955     return (Dali::Toolkit::Control *)jarg1;
95956 }
95957
95958 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95959     return (Dali::Toolkit::Control *)jarg1;
95960 }
95961
95962 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95963     return (Dali::Toolkit::Control *)jarg1;
95964 }
95965
95966 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95967     return (Dali::Toolkit::PageTurnView *)jarg1;
95968 }
95969
95970 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95971     return (Dali::Toolkit::PageTurnView *)jarg1;
95972 }
95973
95974 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95975     return (Dali::Toolkit::Button *)jarg1;
95976 }
95977
95978 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95979     return (Dali::BaseHandle *)jarg1;
95980 }
95981
95982 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95983     return (Dali::BaseHandle *)jarg1;
95984 }
95985
95986 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95987     return (Dali::BaseHandle *)jarg1;
95988 }
95989
95990 /*
95991  * Widget binding
95992  */
95993 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95994     return (Dali::BaseHandle *)jarg1;
95995 }
95996
95997 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95998     return (Dali::BaseObject *)jarg1;
95999 }
96000
96001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
96002   void * jresult ;
96003   Dali::Widget result;
96004
96005   {
96006     try {
96007       result = Dali::Widget::New();
96008     } catch (std::out_of_range& e) {
96009       {
96010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96011       };
96012     } catch (std::exception& e) {
96013       {
96014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96015       };
96016     } catch (...) {
96017       {
96018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96019       };
96020     }
96021   }
96022   jresult = new Dali::Widget((const Dali::Widget &)result);
96023   return jresult;
96024 }
96025
96026
96027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
96028   void * jresult ;
96029   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
96030   Dali::Widget result;
96031
96032   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96033
96034   if (!arg1) {
96035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
96036     return 0;
96037   }
96038   {
96039     try {
96040       jresult = new Dali::Widget(arg1);
96041     } catch (std::out_of_range& e) {
96042       {
96043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96044       };
96045     } catch (std::exception& e) {
96046       {
96047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96048       };
96049     } catch (...) {
96050       {
96051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96052       };
96053     }
96054   }
96055   return jresult;
96056 }
96057
96058
96059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
96060   void * jresult ;
96061   Dali::Widget *result = 0 ;
96062
96063   {
96064     try {
96065       result = (Dali::Widget *)new Dali::Widget();
96066     } catch (std::out_of_range& e) {
96067       {
96068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96069       };
96070     } catch (std::exception& e) {
96071       {
96072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96073       };
96074     } catch (...) {
96075       {
96076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96077       };
96078     }
96079   }
96080   jresult = (void *)result;
96081   return jresult;
96082 }
96083
96084
96085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
96086   void * jresult ;
96087   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96088   Dali::Widget *arg2 = 0 ;
96089   Dali::Widget *result = 0 ;
96090
96091   arg1 = (Dali::Widget *)jarg1;
96092   arg2 = (Dali::Widget *)jarg2;
96093   if (!arg2) {
96094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
96095     return 0;
96096   }
96097   {
96098     try {
96099       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
96100     } catch (std::out_of_range& e) {
96101       {
96102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96103       };
96104     } catch (std::exception& e) {
96105       {
96106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96107       };
96108     } catch (...) {
96109       {
96110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96111       };
96112     }
96113   }
96114   jresult = (void *)result;
96115   return jresult;
96116 }
96117
96118
96119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
96120   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96121
96122   arg1 = (Dali::Widget *)jarg1;
96123   {
96124     try {
96125       delete arg1;
96126     } catch (std::out_of_range& e) {
96127       {
96128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96129       };
96130     } catch (std::exception& e) {
96131       {
96132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96133       };
96134     } catch (...) {
96135       {
96136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96137       };
96138     }
96139   }
96140 }
96141
96142
96143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
96144   void * jresult ;
96145   SwigDirector_WidgetImpl* result;
96146   {
96147     try {
96148       result = new SwigDirector_WidgetImpl();
96149     } catch (std::out_of_range& e) {
96150       {
96151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96152       };
96153     } catch (std::exception& e) {
96154       {
96155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96156       };
96157     } catch (...) {
96158       {
96159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96160       };
96161     }
96162   }
96163   jresult = result;
96164   return jresult;
96165 }
96166
96167
96168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
96169   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96170   std::string *arg2 = 0 ;
96171   Dali::Window arg3 ;
96172   Dali::Window *argp3 ;
96173
96174   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96175   if (!jarg2) {
96176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96177     return ;
96178   }
96179   std::string arg2_str(jarg2);
96180   arg2 = &arg2_str;
96181   argp3 = (Dali::Window *)jarg3;
96182   if (!argp3) {
96183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96184     return ;
96185   }
96186   arg3 = *argp3;
96187   {
96188     try {
96189       (arg1)->OnCreate((std::string const &)*arg2,arg3);
96190     } catch (std::out_of_range& e) {
96191       {
96192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96193       };
96194     } catch (std::exception& e) {
96195       {
96196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96197       };
96198     } catch (...) {
96199       {
96200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96201       };
96202     }
96203   }
96204 }
96205
96206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96207   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96208   std::string *arg2 = 0 ;
96209   Dali::Window arg3 ;
96210   Dali::Window *argp3 ;
96211
96212   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96213   if (!jarg2) {
96214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96215     return ;
96216   }
96217   std::string arg2_str(jarg2);
96218   arg2 = &arg2_str;
96219   argp3 = (Dali::Window *)jarg3;
96220   if (!argp3) {
96221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96222     return ;
96223   }
96224   arg3 = *argp3;
96225   {
96226     try {
96227       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96228     } catch (std::out_of_range& e) {
96229       {
96230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96231       };
96232     } catch (std::exception& e) {
96233       {
96234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96235       };
96236     } catch (...) {
96237       {
96238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96239       };
96240     }
96241   }
96242 }
96243
96244
96245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96246   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96247   std::string *arg2 = 0 ;
96248   Dali::Widget::Termination arg3 ;
96249
96250   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96251   if (!jarg2) {
96252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96253     return ;
96254   }
96255   std::string arg2_str(jarg2);
96256   arg2 = &arg2_str;
96257   arg3 = (Dali::Widget::Termination)jarg3;
96258   {
96259     try {
96260       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96261     } catch (std::out_of_range& e) {
96262       {
96263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96264       };
96265     } catch (std::exception& e) {
96266       {
96267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96268       };
96269     } catch (...) {
96270       {
96271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96272       };
96273     }
96274   }
96275 }
96276
96277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96278   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96279   std::string *arg2 = 0 ;
96280   Dali::Widget::Termination arg3 ;
96281
96282   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96283   if (!jarg2) {
96284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96285     return ;
96286   }
96287   std::string arg2_str(jarg2);
96288   arg2 = &arg2_str;
96289   arg3 = (Dali::Widget::Termination)jarg3;
96290   {
96291     try {
96292       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96293     } catch (std::out_of_range& e) {
96294       {
96295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96296       };
96297     } catch (std::exception& e) {
96298       {
96299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96300       };
96301     } catch (...) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96304       };
96305     }
96306   }
96307 }
96308
96309
96310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96311   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96312
96313   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96314   {
96315     try {
96316       (arg1)->OnPause();
96317     } catch (std::out_of_range& e) {
96318       {
96319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96320       };
96321     } catch (std::exception& e) {
96322       {
96323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96324       };
96325     } catch (...) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96328       };
96329     }
96330   }
96331 }
96332
96333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96334   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96335
96336   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96337   {
96338     try {
96339       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96340     } catch (std::out_of_range& e) {
96341       {
96342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96343       };
96344     } catch (std::exception& e) {
96345       {
96346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96347       };
96348     } catch (...) {
96349       {
96350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96351       };
96352     }
96353   }
96354 }
96355
96356
96357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96358   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96359
96360   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96361   {
96362     try {
96363       (arg1)->OnResume();
96364     } catch (std::out_of_range& e) {
96365       {
96366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96367       };
96368     } catch (std::exception& e) {
96369       {
96370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96371       };
96372     } catch (...) {
96373       {
96374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96375       };
96376     }
96377   }
96378 }
96379
96380
96381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96382   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96383
96384   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96385   {
96386     try {
96387       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96388     } catch (std::out_of_range& e) {
96389       {
96390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96391       };
96392     } catch (std::exception& e) {
96393       {
96394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96395       };
96396     } catch (...) {
96397       {
96398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96399       };
96400     }
96401   }
96402 }
96403
96404
96405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96406   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96407   Dali::Window arg2 ;
96408   Dali::Window *argp2 ;
96409
96410   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96411   argp2 = (Dali::Window *)jarg2;
96412   if (!argp2) {
96413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96414     return ;
96415   }
96416   arg2 = *argp2;
96417   {
96418     try {
96419       (arg1)->OnResize(arg2);
96420     } catch (std::out_of_range& e) {
96421       {
96422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (std::exception& e) {
96425       {
96426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96427       };
96428     } catch (...) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96431       };
96432     }
96433   }
96434 }
96435
96436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96437   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96438   Dali::Window arg2 ;
96439   Dali::Window *argp2 ;
96440
96441   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96442   argp2 = (Dali::Window *)jarg2;
96443   if (!argp2) {
96444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96445     return ;
96446   }
96447   arg2 = *argp2;
96448   {
96449     try {
96450       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96451     } catch (std::out_of_range& e) {
96452       {
96453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96454       };
96455     } catch (std::exception& e) {
96456       {
96457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96458       };
96459     } catch (...) {
96460       {
96461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96462       };
96463     }
96464   }
96465 }
96466
96467
96468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96469   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96470   std::string *arg2 = 0 ;
96471   int arg3 ;
96472
96473   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96474   if (!jarg2) {
96475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96476     return ;
96477   }
96478   std::string arg2_str(jarg2);
96479   arg2 = &arg2_str;
96480   arg3 = (int)jarg3;
96481   {
96482     try {
96483       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96484     } catch (std::out_of_range& e) {
96485       {
96486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96487       };
96488     } catch (std::exception& e) {
96489       {
96490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96491       };
96492     } catch (...) {
96493       {
96494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96495       };
96496     }
96497   }
96498 }
96499
96500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96501   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96502   std::string *arg2 = 0 ;
96503   int arg3 ;
96504
96505   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96506   if (!jarg2) {
96507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96508     return ;
96509   }
96510   std::string arg2_str(jarg2);
96511   arg2 = &arg2_str;
96512   arg3 = (int)jarg3;
96513   {
96514     try {
96515       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96516     } catch (std::out_of_range& e) {
96517       {
96518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96519       };
96520     } catch (std::exception& e) {
96521       {
96522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96523       };
96524     } catch (...) {
96525       {
96526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96527       };
96528     }
96529   }
96530 }
96531
96532
96533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96534   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96535   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96536   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96537
96538   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96539   arg2 = (Dali::SlotObserver *)jarg2;
96540   arg3 = (Dali::CallbackBase *)jarg3;
96541   {
96542     try {
96543       (arg1)->SignalConnected(arg2,arg3);
96544     } catch (std::out_of_range& e) {
96545       {
96546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96547       };
96548     } catch (std::exception& e) {
96549       {
96550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96551       };
96552     } catch (...) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96555       };
96556     }
96557   }
96558 }
96559
96560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96561   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96562   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96563   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96564
96565   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96566   arg2 = (Dali::SlotObserver *)jarg2;
96567   arg3 = (Dali::CallbackBase *)jarg3;
96568   {
96569     try {
96570       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96571     } catch (std::out_of_range& e) {
96572       {
96573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96574       };
96575     } catch (std::exception& e) {
96576       {
96577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96578       };
96579     } catch (...) {
96580       {
96581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96582       };
96583     }
96584   }
96585 }
96586
96587
96588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96589   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96590   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96591   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96592
96593   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96594   arg2 = (Dali::SlotObserver *)jarg2;
96595   arg3 = (Dali::CallbackBase *)jarg3;
96596   {
96597     try {
96598       (arg1)->SignalDisconnected(arg2,arg3);
96599     } catch (std::out_of_range& e) {
96600       {
96601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96602       };
96603     } catch (std::exception& e) {
96604       {
96605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96606       };
96607     } catch (...) {
96608       {
96609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96610       };
96611     }
96612   }
96613 }
96614
96615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96616   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96617   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96618   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96619
96620   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96621   arg2 = (Dali::SlotObserver *)jarg2;
96622   arg3 = (Dali::CallbackBase *)jarg3;
96623   {
96624     try {
96625       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96626     } catch (std::out_of_range& e) {
96627       {
96628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96629       };
96630     } catch (std::exception& e) {
96631       {
96632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96633       };
96634     } catch (...) {
96635       {
96636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96637       };
96638     }
96639   }
96640 }
96641
96642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96643   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96644   std::string *arg2 = 0 ;
96645
96646   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96647   if (!jarg2) {
96648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96649     return ;
96650   }
96651   std::string arg2_str(jarg2);
96652   arg2 = &arg2_str;
96653   {
96654     try {
96655       (arg1)->SetContentInfo((std::string const &)*arg2);
96656     } catch (std::out_of_range& e) {
96657       {
96658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96659       };
96660     } catch (std::exception& e) {
96661       {
96662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96663       };
96664     } catch (...) {
96665       {
96666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96667       };
96668     }
96669   }
96670 }
96671
96672
96673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96674   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96675   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96676
96677   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96678   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96679   {
96680     try {
96681       (arg1)->SetImpl(arg2);
96682     } catch (std::out_of_range& e) {
96683       {
96684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96685       };
96686     } catch (std::exception& e) {
96687       {
96688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96689       };
96690     } catch (...) {
96691       {
96692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96693       };
96694     }
96695   }
96696 }
96697
96698 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) {
96699
96700   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96701   if (director) {
96702     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96703   }
96704 }
96705
96706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96707   void * jresult ;
96708   Dali::Widget *arg1 = 0 ;
96709   SwigDirector_WidgetImpl *result = 0 ;
96710
96711   arg1 = (Dali::Widget *)jarg1;
96712   if (!arg1) {
96713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96714     return 0;
96715   }
96716   {
96717     try {
96718       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96719     } catch (std::out_of_range& e) {
96720       {
96721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96722       };
96723     } catch (std::exception& e) {
96724       {
96725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96726       };
96727     } catch (...) {
96728       {
96729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96730       };
96731     }
96732   }
96733
96734   jresult = (void *)result;
96735   return jresult;
96736 }
96737
96738
96739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96740   void * jresult ;
96741   int *arg1 = (int *) 0 ;
96742   char ***arg2 ;
96743   std::string *arg3 = 0 ;
96744   Dali::WidgetApplication result;
96745   {
96746     int index = 0;
96747     int length = 0;
96748     char *retPtr;
96749     char *nextPtr;
96750     argWidgetC = jarg1;
96751     argWidgetV = new char*[jarg1 + 1];
96752
96753     retPtr = strtok_r( jarg2, " ", &nextPtr);
96754     if( retPtr )
96755     {
96756       length = strlen(retPtr);
96757     }
96758     argWidgetV[index] = new char[length + 1];
96759     if( retPtr )
96760     {
96761       strncpy(argWidgetV[index], retPtr, length);
96762     }
96763     argWidgetV[index][length] = '\0';
96764     index++;
96765
96766     while (index < jarg1)
96767     {
96768       length = 0;
96769       retPtr = strtok_r(NULL, " ", &nextPtr);
96770       if( retPtr )
96771       {
96772         length = strlen(retPtr);
96773       }
96774       argWidgetV[index] = new char[length + 1];
96775       if( retPtr )
96776       {
96777         strncpy(argWidgetV[index], retPtr, length);
96778       }
96779       argWidgetV[index][length] = '\0';
96780       index++;
96781     }
96782
96783     argWidgetV[jarg1] = NULL;
96784     argWidgetC = jarg1;
96785
96786     arg1 = &argWidgetC;
96787     arg2 = &argWidgetV;
96788   }
96789
96790   if (!jarg3) {
96791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96792     return 0;
96793   }
96794   std::string arg3_str(jarg3);
96795   arg3 = &arg3_str;
96796   {
96797     try {
96798       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
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::WidgetApplication((const Dali::WidgetApplication &)result);
96814
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96820   void * jresult ;
96821   Dali::WidgetApplication *result = 0 ;
96822
96823   {
96824     try {
96825       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96826     } catch (std::out_of_range& e) {
96827       {
96828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96829       };
96830     } catch (std::exception& e) {
96831       {
96832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96833       };
96834     } catch (...) {
96835       {
96836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96837       };
96838     }
96839   }
96840   jresult = (void *)result;
96841   return jresult;
96842 }
96843
96844
96845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96846   void * jresult ;
96847   Dali::WidgetApplication *arg1 = 0 ;
96848   Dali::WidgetApplication *result = 0 ;
96849
96850   arg1 = (Dali::WidgetApplication *)jarg1;
96851   if (!arg1) {
96852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96853     return 0;
96854   }
96855   {
96856     try {
96857       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96858     } catch (std::out_of_range& e) {
96859       {
96860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96861       };
96862     } catch (std::exception& e) {
96863       {
96864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96865       };
96866     } catch (...) {
96867       {
96868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96869       };
96870     }
96871   }
96872   jresult = (void *)result;
96873   return jresult;
96874 }
96875
96876
96877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96878   void * jresult ;
96879   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96880   Dali::WidgetApplication *arg2 = 0 ;
96881   Dali::WidgetApplication *result = 0 ;
96882
96883   arg1 = (Dali::WidgetApplication *)jarg1;
96884   arg2 = (Dali::WidgetApplication *)jarg2;
96885   if (!arg2) {
96886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96887     return 0;
96888   }
96889   {
96890     try {
96891       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96892     } catch (std::out_of_range& e) {
96893       {
96894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96895       };
96896     } catch (std::exception& e) {
96897       {
96898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96899       };
96900     } catch (...) {
96901       {
96902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96903       };
96904     }
96905   }
96906   jresult = (void *)result;
96907   return jresult;
96908 }
96909
96910
96911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96912   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96913
96914   arg1 = (Dali::WidgetApplication *)jarg1;
96915   {
96916     try {
96917       delete arg1;
96918       if( argWidgetV )
96919       {
96920         // free string data
96921         for( int i=0; i < argWidgetC+1; i++)
96922         {
96923           delete [] argWidgetV[i];
96924         }
96925         delete [] argWidgetV;
96926       }
96927     } catch (std::out_of_range& e) {
96928       {
96929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96930       };
96931     } catch (std::exception& e) {
96932       {
96933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96934       };
96935     } catch (...) {
96936       {
96937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96938       };
96939     }
96940   }
96941 }
96942
96943
96944 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96945 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96946
96947 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96948 {
96949   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96950   return *widget;
96951 }
96952
96953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96954   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96955   std::string *arg2 = 0 ;
96956
96957   arg1 = (Dali::WidgetApplication *)jarg1;
96958   if (!jarg2) {
96959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96960     return ;
96961   }
96962   std::string arg2_str(*jarg2);
96963   arg2 = &arg2_str;
96964
96965   if(!_CSharpCreateWidgetFunction)
96966   {
96967     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96968   }
96969
96970   {
96971     try {
96972       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96973     } catch (std::out_of_range& e) {
96974       {
96975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96976       };
96977     } catch (std::exception& e) {
96978       {
96979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96980       };
96981     } catch (...) {
96982       {
96983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96984       };
96985     }
96986   }
96987
96988   //Typemap argout in c++ file.
96989   //This will convert c++ string to c# string
96990   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96991 }
96992
96993
96994 //for PixelBuffer and ImageLoading
96995
96996 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96997     return (Dali::BaseHandle *)jarg1;
96998 }
96999
97000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
97001   void * jresult ;
97002   unsigned int arg1 ;
97003   unsigned int arg2 ;
97004   Dali::Pixel::Format arg3 ;
97005   Dali::Devel::PixelBuffer result;
97006
97007   arg1 = (unsigned int)jarg1;
97008   arg2 = (unsigned int)jarg2;
97009   arg3 = (Dali::Pixel::Format)jarg3;
97010   {
97011     try {
97012       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
97013     } catch (std::out_of_range& e) {
97014       {
97015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97016       };
97017     } catch (std::exception& e) {
97018       {
97019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97020       };
97021     } catch (...) {
97022       {
97023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97024       };
97025     }
97026   }
97027   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97028   return jresult;
97029 }
97030
97031
97032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
97033   void * jresult ;
97034   Dali::Devel::PixelBuffer *result = 0 ;
97035
97036   {
97037     try {
97038       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
97039     } catch (std::out_of_range& e) {
97040       {
97041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97042       };
97043     } catch (std::exception& e) {
97044       {
97045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97046       };
97047     } catch (...) {
97048       {
97049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97050       };
97051     }
97052   }
97053   jresult = (void *)result;
97054   return jresult;
97055 }
97056
97057
97058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
97059   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97060
97061   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97062   {
97063     try {
97064       delete arg1;
97065     } catch (std::out_of_range& e) {
97066       {
97067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97068       };
97069     } catch (std::exception& e) {
97070       {
97071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97072       };
97073     } catch (...) {
97074       {
97075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97076       };
97077     }
97078   }
97079 }
97080
97081
97082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
97083   void * jresult ;
97084   Dali::Devel::PixelBuffer *arg1 = 0 ;
97085   Dali::Devel::PixelBuffer *result = 0 ;
97086
97087   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97088   if (!arg1) {
97089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97090     return 0;
97091   }
97092   {
97093     try {
97094       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
97095     } catch (std::out_of_range& e) {
97096       {
97097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97098       };
97099     } catch (std::exception& e) {
97100       {
97101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97102       };
97103     } catch (...) {
97104       {
97105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97106       };
97107     }
97108   }
97109   jresult = (void *)result;
97110   return jresult;
97111 }
97112
97113
97114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
97115   void * jresult ;
97116   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97117   Dali::Devel::PixelBuffer *arg2 = 0 ;
97118   Dali::Devel::PixelBuffer *result = 0 ;
97119
97120   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97121   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
97122   if (!arg2) {
97123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97124     return 0;
97125   }
97126   {
97127     try {
97128       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
97129     } catch (std::out_of_range& e) {
97130       {
97131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97132       };
97133     } catch (std::exception& e) {
97134       {
97135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97136       };
97137     } catch (...) {
97138       {
97139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97140       };
97141     }
97142   }
97143   jresult = (void *)result;
97144   return jresult;
97145 }
97146
97147
97148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
97149   void * jresult ;
97150   Dali::Devel::PixelBuffer *arg1 = 0 ;
97151   Dali::PixelData result;
97152
97153   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97154   if (!arg1) {
97155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
97156     return 0;
97157   }
97158   {
97159     try {
97160       result = Dali::Devel::PixelBuffer::Convert(*arg1);
97161     } catch (std::out_of_range& e) {
97162       {
97163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97164       };
97165     } catch (std::exception& e) {
97166       {
97167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97168       };
97169     } catch (...) {
97170       {
97171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97172       };
97173     }
97174   }
97175   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97176   return jresult;
97177 }
97178
97179
97180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
97181   void * jresult ;
97182   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97183   Dali::PixelData result;
97184
97185   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97186   {
97187     try {
97188       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97189     } catch (std::out_of_range& e) {
97190       {
97191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97192       };
97193     } catch (std::exception& e) {
97194       {
97195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97196       };
97197     } catch (...) {
97198       {
97199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97200       };
97201     }
97202   }
97203   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97204   return jresult;
97205 }
97206
97207
97208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97209   void * jresult ;
97210   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97211   unsigned char *result = 0 ;
97212
97213   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97214   {
97215     try {
97216       result = (unsigned char *)(arg1)->GetBuffer();
97217     } catch (std::out_of_range& e) {
97218       {
97219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97220       };
97221     } catch (std::exception& e) {
97222       {
97223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97224       };
97225     } catch (...) {
97226       {
97227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97228       };
97229     }
97230   }
97231   jresult = (void *)result;
97232   return jresult;
97233 }
97234
97235
97236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97237   unsigned int jresult ;
97238   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97239   unsigned int result;
97240
97241   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97242   {
97243     try {
97244       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97245     } catch (std::out_of_range& e) {
97246       {
97247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97248       };
97249     } catch (std::exception& e) {
97250       {
97251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97252       };
97253     } catch (...) {
97254       {
97255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97256       };
97257     }
97258   }
97259   jresult = result;
97260   return jresult;
97261 }
97262
97263
97264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97265   unsigned int jresult ;
97266   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97267   unsigned int result;
97268
97269   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97270   {
97271     try {
97272       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97273     } catch (std::out_of_range& e) {
97274       {
97275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97276       };
97277     } catch (std::exception& e) {
97278       {
97279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97280       };
97281     } catch (...) {
97282       {
97283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97284       };
97285     }
97286   }
97287   jresult = result;
97288   return jresult;
97289 }
97290
97291
97292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97293   int jresult ;
97294   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97295   Dali::Pixel::Format result;
97296
97297   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97298   {
97299     try {
97300       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97301     } catch (std::out_of_range& e) {
97302       {
97303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97304       };
97305     } catch (std::exception& e) {
97306       {
97307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97308       };
97309     } catch (...) {
97310       {
97311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97312       };
97313     }
97314   }
97315   jresult = (int)result;
97316   return jresult;
97317 }
97318
97319
97320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97321   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97322   Dali::Devel::PixelBuffer arg2 ;
97323   float arg3 ;
97324   bool arg4 ;
97325   Dali::Devel::PixelBuffer *argp2 ;
97326
97327   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97328   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97329   if (!argp2) {
97330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97331     return ;
97332   }
97333   arg2 = *argp2;
97334   arg3 = (float)jarg3;
97335   arg4 = jarg4 ? true : false;
97336   {
97337     try {
97338       (arg1)->ApplyMask(arg2,arg3,arg4);
97339     } catch (std::out_of_range& e) {
97340       {
97341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97342       };
97343     } catch (std::exception& e) {
97344       {
97345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97346       };
97347     } catch (...) {
97348       {
97349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97350       };
97351     }
97352   }
97353 }
97354
97355
97356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97357   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97358   Dali::Devel::PixelBuffer arg2 ;
97359   float arg3 ;
97360   Dali::Devel::PixelBuffer *argp2 ;
97361
97362   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97363   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97364   if (!argp2) {
97365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97366     return ;
97367   }
97368   arg2 = *argp2;
97369   arg3 = (float)jarg3;
97370   {
97371     try {
97372       (arg1)->ApplyMask(arg2,arg3);
97373     } catch (std::out_of_range& e) {
97374       {
97375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97376       };
97377     } catch (std::exception& e) {
97378       {
97379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97380       };
97381     } catch (...) {
97382       {
97383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97384       };
97385     }
97386   }
97387 }
97388
97389
97390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97391   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97392   Dali::Devel::PixelBuffer arg2 ;
97393   Dali::Devel::PixelBuffer *argp2 ;
97394
97395   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97396   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97397   if (!argp2) {
97398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97399     return ;
97400   }
97401   arg2 = *argp2;
97402   {
97403     try {
97404       (arg1)->ApplyMask(arg2);
97405     } catch (std::out_of_range& e) {
97406       {
97407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97408       };
97409     } catch (std::exception& e) {
97410       {
97411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97412       };
97413     } catch (...) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97416       };
97417     }
97418   }
97419 }
97420
97421
97422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97423   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97424   float arg2 ;
97425
97426   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97427   arg2 = (float)jarg2;
97428   {
97429     try {
97430       (arg1)->ApplyGaussianBlur(arg2);
97431     } catch (std::out_of_range& e) {
97432       {
97433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97434       };
97435     } catch (std::exception& e) {
97436       {
97437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97438       };
97439     } catch (...) {
97440       {
97441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97442       };
97443     }
97444   }
97445 }
97446
97447
97448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97449   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97450   uint16_t arg2 ;
97451   uint16_t arg3 ;
97452   uint16_t arg4 ;
97453   uint16_t arg5 ;
97454
97455   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97456   arg2 = (uint16_t)jarg2;
97457   arg3 = (uint16_t)jarg3;
97458   arg4 = (uint16_t)jarg4;
97459   arg5 = (uint16_t)jarg5;
97460   {
97461     try {
97462       (arg1)->Crop(arg2,arg3,arg4,arg5);
97463     } catch (std::out_of_range& e) {
97464       {
97465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97466       };
97467     } catch (std::exception& e) {
97468       {
97469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97470       };
97471     } catch (...) {
97472       {
97473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97474       };
97475     }
97476   }
97477 }
97478
97479
97480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97481   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97482   uint16_t arg2 ;
97483   uint16_t arg3 ;
97484
97485   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97486   arg2 = (uint16_t)jarg2;
97487   arg3 = (uint16_t)jarg3;
97488   {
97489     try {
97490       (arg1)->Resize(arg2,arg3);
97491     } catch (std::out_of_range& e) {
97492       {
97493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97494       };
97495     } catch (std::exception& e) {
97496       {
97497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97498       };
97499     } catch (...) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97502       };
97503     }
97504   }
97505 }
97506
97507 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97508   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97509   Dali::Degree * arg2 ;
97510
97511   bool result = false;
97512
97513   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97514   arg2 = (Dali::Degree *)jarg2;
97515   {
97516     try {
97517       result = (arg1)->Rotate(*arg2);
97518     } catch (std::out_of_range& e) {
97519       {
97520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97521       };
97522     } catch (std::exception& e) {
97523       {
97524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97525       };
97526     } catch (...) {
97527       {
97528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97529       };
97530     }
97531   }
97532   return result;
97533 }
97534
97535
97536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97537   void * jresult ;
97538   std::string *arg1 = 0 ;
97539   Dali::ImageDimensions arg2 ;
97540   Dali::FittingMode::Type arg3 ;
97541   Dali::SamplingMode::Type arg4 ;
97542   bool arg5 ;
97543   Dali::ImageDimensions *argp2 ;
97544   Dali::Devel::PixelBuffer result;
97545
97546   if (!jarg1) {
97547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97548     return 0;
97549   }
97550   std::string arg1_str(jarg1);
97551   arg1 = &arg1_str;
97552   argp2 = (Dali::ImageDimensions *)jarg2;
97553   if (!argp2) {
97554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97555     return 0;
97556   }
97557   arg2 = *argp2;
97558   arg3 = (Dali::FittingMode::Type)jarg3;
97559   arg4 = (Dali::SamplingMode::Type)jarg4;
97560   arg5 = jarg5 ? true : false;
97561   {
97562     try {
97563       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97564     } catch (std::out_of_range& e) {
97565       {
97566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97567       };
97568     } catch (std::exception& e) {
97569       {
97570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97571       };
97572     } catch (...) {
97573       {
97574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97575       };
97576     }
97577   }
97578   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97579
97580   return jresult;
97581 }
97582
97583
97584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97585   void * jresult ;
97586   std::string *arg1 = 0 ;
97587   Dali::ImageDimensions arg2 ;
97588   Dali::FittingMode::Type arg3 ;
97589   Dali::SamplingMode::Type arg4 ;
97590   Dali::ImageDimensions *argp2 ;
97591   Dali::Devel::PixelBuffer result;
97592
97593   if (!jarg1) {
97594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97595     return 0;
97596   }
97597   std::string arg1_str(jarg1);
97598   arg1 = &arg1_str;
97599   argp2 = (Dali::ImageDimensions *)jarg2;
97600   if (!argp2) {
97601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97602     return 0;
97603   }
97604   arg2 = *argp2;
97605   arg3 = (Dali::FittingMode::Type)jarg3;
97606   arg4 = (Dali::SamplingMode::Type)jarg4;
97607   {
97608     try {
97609       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97610     } catch (std::out_of_range& e) {
97611       {
97612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97613       };
97614     } catch (std::exception& e) {
97615       {
97616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97617       };
97618     } catch (...) {
97619       {
97620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97621       };
97622     }
97623   }
97624   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97625
97626   return jresult;
97627 }
97628
97629
97630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97631   void * jresult ;
97632   std::string *arg1 = 0 ;
97633   Dali::ImageDimensions arg2 ;
97634   Dali::FittingMode::Type arg3 ;
97635   Dali::ImageDimensions *argp2 ;
97636   Dali::Devel::PixelBuffer result;
97637
97638   if (!jarg1) {
97639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97640     return 0;
97641   }
97642   std::string arg1_str(jarg1);
97643   arg1 = &arg1_str;
97644   argp2 = (Dali::ImageDimensions *)jarg2;
97645   if (!argp2) {
97646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97647     return 0;
97648   }
97649   arg2 = *argp2;
97650   arg3 = (Dali::FittingMode::Type)jarg3;
97651   {
97652     try {
97653       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97654     } catch (std::out_of_range& e) {
97655       {
97656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97657       };
97658     } catch (std::exception& e) {
97659       {
97660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97661       };
97662     } catch (...) {
97663       {
97664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97665       };
97666     }
97667   }
97668   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97669
97670   return jresult;
97671 }
97672
97673
97674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97675   void * jresult ;
97676   std::string *arg1 = 0 ;
97677   Dali::ImageDimensions arg2 ;
97678   Dali::ImageDimensions *argp2 ;
97679   Dali::Devel::PixelBuffer result;
97680
97681   if (!jarg1) {
97682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97683     return 0;
97684   }
97685   std::string arg1_str(jarg1);
97686   arg1 = &arg1_str;
97687   argp2 = (Dali::ImageDimensions *)jarg2;
97688   if (!argp2) {
97689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97690     return 0;
97691   }
97692   arg2 = *argp2;
97693   {
97694     try {
97695       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97696     } catch (std::out_of_range& e) {
97697       {
97698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97699       };
97700     } catch (std::exception& e) {
97701       {
97702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97703       };
97704     } catch (...) {
97705       {
97706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97707       };
97708     }
97709   }
97710   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97711
97712   return jresult;
97713 }
97714
97715
97716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97717   void * jresult ;
97718   std::string *arg1 = 0 ;
97719   Dali::Devel::PixelBuffer result;
97720
97721   if (!jarg1) {
97722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97723     return 0;
97724   }
97725   std::string arg1_str(jarg1);
97726   arg1 = &arg1_str;
97727   {
97728     try {
97729       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97730     } catch (std::out_of_range& e) {
97731       {
97732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97733       };
97734     } catch (std::exception& e) {
97735       {
97736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97737       };
97738     } catch (...) {
97739       {
97740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97741       };
97742     }
97743   }
97744   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97745
97746   return jresult;
97747 }
97748
97749
97750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97751   void * jresult ;
97752   std::string *arg1 = 0 ;
97753   Dali::ImageDimensions arg2 ;
97754   Dali::FittingMode::Type arg3 ;
97755   Dali::SamplingMode::Type arg4 ;
97756   bool arg5 ;
97757   Dali::ImageDimensions *argp2 ;
97758   Dali::ImageDimensions result;
97759
97760   if (!jarg1) {
97761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97762     return 0;
97763   }
97764   std::string arg1_str(jarg1);
97765   arg1 = &arg1_str;
97766   argp2 = (Dali::ImageDimensions *)jarg2;
97767   if (!argp2) {
97768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97769     return 0;
97770   }
97771   arg2 = *argp2;
97772   arg3 = (Dali::FittingMode::Type)jarg3;
97773   arg4 = (Dali::SamplingMode::Type)jarg4;
97774   arg5 = jarg5 ? true : false;
97775   {
97776     try {
97777       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97778     } catch (std::out_of_range& e) {
97779       {
97780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97781       };
97782     } catch (std::exception& e) {
97783       {
97784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97785       };
97786     } catch (...) {
97787       {
97788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97789       };
97790     }
97791   }
97792   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97793
97794   return jresult;
97795 }
97796
97797
97798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97799   void * jresult ;
97800   std::string *arg1 = 0 ;
97801   Dali::ImageDimensions arg2 ;
97802   Dali::FittingMode::Type arg3 ;
97803   Dali::SamplingMode::Type arg4 ;
97804   Dali::ImageDimensions *argp2 ;
97805   Dali::ImageDimensions result;
97806
97807   if (!jarg1) {
97808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97809     return 0;
97810   }
97811   std::string arg1_str(jarg1);
97812   arg1 = &arg1_str;
97813   argp2 = (Dali::ImageDimensions *)jarg2;
97814   if (!argp2) {
97815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97816     return 0;
97817   }
97818   arg2 = *argp2;
97819   arg3 = (Dali::FittingMode::Type)jarg3;
97820   arg4 = (Dali::SamplingMode::Type)jarg4;
97821   {
97822     try {
97823       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97824     } catch (std::out_of_range& e) {
97825       {
97826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97827       };
97828     } catch (std::exception& e) {
97829       {
97830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97831       };
97832     } catch (...) {
97833       {
97834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97835       };
97836     }
97837   }
97838   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97839
97840   return jresult;
97841 }
97842
97843
97844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97845   void * jresult ;
97846   std::string *arg1 = 0 ;
97847   Dali::ImageDimensions arg2 ;
97848   Dali::FittingMode::Type arg3 ;
97849   Dali::ImageDimensions *argp2 ;
97850   Dali::ImageDimensions result;
97851
97852   if (!jarg1) {
97853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97854     return 0;
97855   }
97856   std::string arg1_str(jarg1);
97857   arg1 = &arg1_str;
97858   argp2 = (Dali::ImageDimensions *)jarg2;
97859   if (!argp2) {
97860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97861     return 0;
97862   }
97863   arg2 = *argp2;
97864   arg3 = (Dali::FittingMode::Type)jarg3;
97865   {
97866     try {
97867       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97868     } catch (std::out_of_range& e) {
97869       {
97870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97871       };
97872     } catch (std::exception& e) {
97873       {
97874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97875       };
97876     } catch (...) {
97877       {
97878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97879       };
97880     }
97881   }
97882   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97883
97884   return jresult;
97885 }
97886
97887
97888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97889   void * jresult ;
97890   std::string *arg1 = 0 ;
97891   Dali::ImageDimensions arg2 ;
97892   Dali::ImageDimensions *argp2 ;
97893   Dali::ImageDimensions result;
97894
97895   if (!jarg1) {
97896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97897     return 0;
97898   }
97899   std::string arg1_str(jarg1);
97900   arg1 = &arg1_str;
97901   argp2 = (Dali::ImageDimensions *)jarg2;
97902   if (!argp2) {
97903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97904     return 0;
97905   }
97906   arg2 = *argp2;
97907   {
97908     try {
97909       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97910     } catch (std::out_of_range& e) {
97911       {
97912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97913       };
97914     } catch (std::exception& e) {
97915       {
97916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (...) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97921       };
97922     }
97923   }
97924   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97925
97926   return jresult;
97927 }
97928
97929
97930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97931   void * jresult ;
97932   std::string *arg1 = 0 ;
97933   Dali::ImageDimensions result;
97934
97935   if (!jarg1) {
97936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97937     return 0;
97938   }
97939   std::string arg1_str(jarg1);
97940   arg1 = &arg1_str;
97941   {
97942     try {
97943       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97944     } catch (std::out_of_range& e) {
97945       {
97946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97947       };
97948     } catch (std::exception& e) {
97949       {
97950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97951       };
97952     } catch (...) {
97953       {
97954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97955       };
97956     }
97957   }
97958   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97959
97960   return jresult;
97961 }
97962
97963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97964   void * jresult ;
97965   std::string *arg1 = 0 ;
97966   Dali::ImageDimensions result;
97967
97968   if (!jarg1) {
97969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97970     return 0;
97971   }
97972   std::string arg1_str(jarg1);
97973   arg1 = &arg1_str;
97974   {
97975     try {
97976       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97977     } catch (std::out_of_range& e) {
97978       {
97979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97980       };
97981     } catch (std::exception& e) {
97982       {
97983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97984       };
97985     } catch (...) {
97986       {
97987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97988       };
97989     }
97990   }
97991   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97992
97993   return jresult;
97994 }
97995
97996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97997   void * jresult ;
97998   std::string *arg1 = 0 ;
97999   Dali::ImageDimensions arg2 ;
98000   Dali::FittingMode::Type arg3 ;
98001   Dali::SamplingMode::Type arg4 ;
98002   bool arg5 ;
98003   Dali::ImageDimensions *argp2 ;
98004   Dali::Devel::PixelBuffer result;
98005
98006   if (!jarg1) {
98007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98008     return 0;
98009   }
98010   std::string arg1_str(jarg1);
98011   arg1 = &arg1_str;
98012   argp2 = (Dali::ImageDimensions *)jarg2;
98013   if (!argp2) {
98014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98015     return 0;
98016   }
98017   arg2 = *argp2;
98018   arg3 = (Dali::FittingMode::Type)jarg3;
98019   arg4 = (Dali::SamplingMode::Type)jarg4;
98020   arg5 = jarg5 ? true : false;
98021   {
98022     try {
98023       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98024     } catch (std::out_of_range& e) {
98025       {
98026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98027       };
98028     } catch (std::exception& e) {
98029       {
98030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98031       };
98032     } catch (...) {
98033       {
98034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98035       };
98036     }
98037   }
98038   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98039
98040   return jresult;
98041 }
98042
98043
98044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98045   void * jresult ;
98046   std::string *arg1 = 0 ;
98047   Dali::ImageDimensions arg2 ;
98048   Dali::FittingMode::Type arg3 ;
98049   Dali::SamplingMode::Type arg4 ;
98050   Dali::ImageDimensions *argp2 ;
98051   Dali::Devel::PixelBuffer result;
98052
98053   if (!jarg1) {
98054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98055     return 0;
98056   }
98057   std::string arg1_str(jarg1);
98058   arg1 = &arg1_str;
98059   argp2 = (Dali::ImageDimensions *)jarg2;
98060   if (!argp2) {
98061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98062     return 0;
98063   }
98064   arg2 = *argp2;
98065   arg3 = (Dali::FittingMode::Type)jarg3;
98066   arg4 = (Dali::SamplingMode::Type)jarg4;
98067   {
98068     try {
98069       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
98070     } catch (std::out_of_range& e) {
98071       {
98072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98073       };
98074     } catch (std::exception& e) {
98075       {
98076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98077       };
98078     } catch (...) {
98079       {
98080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98081       };
98082     }
98083   }
98084   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98085
98086   return jresult;
98087 }
98088
98089
98090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98091   void * jresult ;
98092   std::string *arg1 = 0 ;
98093   Dali::ImageDimensions arg2 ;
98094   Dali::FittingMode::Type arg3 ;
98095   Dali::ImageDimensions *argp2 ;
98096   Dali::Devel::PixelBuffer result;
98097
98098   if (!jarg1) {
98099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98100     return 0;
98101   }
98102   std::string arg1_str(jarg1);
98103   arg1 = &arg1_str;
98104   argp2 = (Dali::ImageDimensions *)jarg2;
98105   if (!argp2) {
98106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98107     return 0;
98108   }
98109   arg2 = *argp2;
98110   arg3 = (Dali::FittingMode::Type)jarg3;
98111   {
98112     try {
98113       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
98114     } catch (std::out_of_range& e) {
98115       {
98116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98117       };
98118     } catch (std::exception& e) {
98119       {
98120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98121       };
98122     } catch (...) {
98123       {
98124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98125       };
98126     }
98127   }
98128   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98129
98130   return jresult;
98131 }
98132
98133
98134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
98135   void * jresult ;
98136   std::string *arg1 = 0 ;
98137   Dali::ImageDimensions arg2 ;
98138   Dali::ImageDimensions *argp2 ;
98139   Dali::Devel::PixelBuffer result;
98140
98141   if (!jarg1) {
98142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98143     return 0;
98144   }
98145   std::string arg1_str(jarg1);
98146   arg1 = &arg1_str;
98147   argp2 = (Dali::ImageDimensions *)jarg2;
98148   if (!argp2) {
98149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98150     return 0;
98151   }
98152   arg2 = *argp2;
98153   {
98154     try {
98155       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
98156     } catch (std::out_of_range& e) {
98157       {
98158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98159       };
98160     } catch (std::exception& e) {
98161       {
98162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98163       };
98164     } catch (...) {
98165       {
98166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98167       };
98168     }
98169   }
98170   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98171
98172   return jresult;
98173 }
98174
98175
98176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
98177   void * jresult ;
98178   std::string *arg1 = 0 ;
98179   Dali::Devel::PixelBuffer result;
98180
98181   if (!jarg1) {
98182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98183     return 0;
98184   }
98185   std::string arg1_str(jarg1);
98186   arg1 = &arg1_str;
98187   {
98188     try {
98189       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98190     } catch (std::out_of_range& e) {
98191       {
98192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98193       };
98194     } catch (std::exception& e) {
98195       {
98196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98197       };
98198     } catch (...) {
98199       {
98200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98201       };
98202     }
98203   }
98204   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98205
98206   return jresult;
98207 }
98208
98209
98210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98211   void * jresult ;
98212   Dali::Toolkit::WebView result;
98213
98214   {
98215     try {
98216       result = Dali::Toolkit::WebView::New();
98217     } catch (std::out_of_range& e) {
98218       {
98219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98220       };
98221     } catch (std::exception& e) {
98222       {
98223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98224       };
98225     } catch (Dali::DaliException e) {
98226       {
98227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98228       };
98229     } catch (...) {
98230       {
98231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98232       };
98233     }
98234   }
98235   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98236   return jresult;
98237 }
98238
98239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98240   void * jresult ;
98241   Dali::Toolkit::WebView result;
98242
98243   std::string *arg1;
98244   std::string *arg2;
98245
98246   if (!jarg1) {
98247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98248     return 0;
98249   }
98250   if (!jarg2) {
98251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98252     return 0;
98253   }
98254
98255   std::string jarg1_str = std::string(jarg1);
98256   std::string jarg2_str = std::string(jarg2);
98257
98258   arg1 = &jarg1_str;
98259   arg2 = &jarg2_str;
98260
98261   {
98262     try {
98263       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98264     } catch (std::out_of_range& e) {
98265       {
98266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98267       };
98268     } catch (std::exception& e) {
98269       {
98270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98271       };
98272     } catch (Dali::DaliException e) {
98273       {
98274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98275       };
98276     } catch (...) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98279       };
98280     }
98281   }
98282   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98283   return jresult;
98284 }
98285
98286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98287   void * jresult ;
98288   Dali::Toolkit::WebView *arg1 = 0 ;
98289   Dali::Toolkit::WebView *result = 0 ;
98290
98291   arg1 = (Dali::Toolkit::WebView *)jarg1;
98292   if (!arg1) {
98293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98294     return 0;
98295   }
98296   {
98297     try {
98298       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98299     } catch (std::out_of_range& e) {
98300       {
98301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98302       };
98303     } catch (std::exception& e) {
98304       {
98305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98306       };
98307     } catch (Dali::DaliException e) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98310       };
98311     } catch (...) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98314       };
98315     }
98316   }
98317   jresult = (void *)result;
98318   return jresult;
98319 }
98320
98321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98322   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98323   arg1 = (Dali::Toolkit::WebView *)jarg1;
98324   {
98325     try {
98326       delete arg1;
98327     } catch (std::out_of_range& e) {
98328       {
98329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98330       };
98331     } catch (std::exception& e) {
98332       {
98333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98334       };
98335     } catch (Dali::DaliException e) {
98336       {
98337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98338       };
98339     } catch (...) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98342       };
98343     }
98344   }
98345 }
98346
98347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98348   void * jresult ;
98349   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98350   Dali::Toolkit::WebView *arg2 = 0 ;
98351   Dali::Toolkit::WebView *result = 0 ;
98352
98353   arg1 = (Dali::Toolkit::WebView *)jarg1;
98354   arg2 = (Dali::Toolkit::WebView *)jarg2;
98355   if (!arg2) {
98356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98357     return 0;
98358   }
98359   {
98360     try {
98361       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98362     } catch (std::out_of_range& e) {
98363       {
98364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98365       };
98366     } catch (std::exception& e) {
98367       {
98368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (Dali::DaliException e) {
98371       {
98372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98373       };
98374     } catch (...) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98377       };
98378     }
98379   }
98380   jresult = (void *)result;
98381   return jresult;
98382 }
98383
98384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98385   void * jresult ;
98386   Dali::BaseHandle arg1 ;
98387   Dali::BaseHandle *argp1 ;
98388   Dali::Toolkit::WebView result;
98389
98390   argp1 = (Dali::BaseHandle *)jarg1;
98391   if (!argp1) {
98392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98393     return 0;
98394   }
98395   arg1 = *argp1;
98396   {
98397     try {
98398       result = Dali::Toolkit::WebView::DownCast(arg1);
98399     } catch (std::out_of_range& e) {
98400       {
98401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98402       };
98403     } catch (std::exception& e) {
98404       {
98405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98406       };
98407     } catch (Dali::DaliException e) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98410       };
98411     } catch (...) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98414       };
98415     }
98416   }
98417   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98418   return jresult;
98419 }
98420
98421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98422   return (int) Dali::Toolkit::WebView::Property::URL;
98423 }
98424
98425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98426   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98427 }
98428
98429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98430   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98431 }
98432
98433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98434   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98435 }
98436
98437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98438   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98439 }
98440
98441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98442   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98443 }
98444
98445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98446   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98447 }
98448
98449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98450   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98451 }
98452
98453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98454   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98455   std::string *arg2;
98456
98457   arg1 = (Dali::Toolkit::WebView *)jarg1;
98458
98459   if (!jarg2) {
98460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98461     return;
98462   }
98463
98464   std::string jarg2str = std::string(jarg2);
98465   arg2 = &jarg2str;
98466   {
98467     try {
98468       (arg1)->LoadUrl((std::string const &)*arg2);
98469     } catch (std::out_of_range& e) {
98470       {
98471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98472       };
98473     } catch (std::exception& e) {
98474       {
98475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98476       };
98477     } catch (Dali::DaliException e) {
98478       {
98479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98480       };
98481     } catch (...) {
98482       {
98483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98484       };
98485     }
98486   }
98487 }
98488
98489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98490   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98491   std::string *arg2;
98492
98493   arg1 = (Dali::Toolkit::WebView *)jarg1;
98494   if (!jarg2) {
98495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98496     return;
98497   }
98498   std::string jarg2str = std::string(jarg2);
98499   arg2 = &jarg2str;
98500   {
98501     try {
98502       (arg1)->LoadHTMLString((std::string const &)*arg2);
98503     } catch (std::out_of_range& e) {
98504       {
98505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98506       };
98507     } catch (std::exception& e) {
98508       {
98509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98510       };
98511     } catch (Dali::DaliException e) {
98512       {
98513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98514       };
98515     } catch (...) {
98516       {
98517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98518       };
98519     }
98520   }
98521 }
98522
98523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98524   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98525
98526   arg1 = (Dali::Toolkit::WebView *)jarg1;
98527   {
98528     try {
98529       (arg1)->Reload();
98530     } catch (std::out_of_range& e) {
98531       {
98532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98533       };
98534     } catch (std::exception& e) {
98535       {
98536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98537       };
98538     } catch (Dali::DaliException e) {
98539       {
98540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98541       };
98542     } catch (...) {
98543       {
98544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98545       };
98546     }
98547   }
98548 }
98549
98550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98551   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98552
98553   arg1 = (Dali::Toolkit::WebView *)jarg1;
98554   {
98555     try {
98556       (arg1)->StopLoading();
98557     } catch (std::out_of_range& e) {
98558       {
98559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98560       };
98561     } catch (std::exception& e) {
98562       {
98563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98564       };
98565     } catch (Dali::DaliException e) {
98566       {
98567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98568       };
98569     } catch (...) {
98570       {
98571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98572       };
98573     }
98574   }
98575 }
98576
98577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98578   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98579
98580   arg1 = (Dali::Toolkit::WebView *)jarg1;
98581   {
98582     try {
98583       (arg1)->Suspend();
98584     } catch (std::out_of_range& e) {
98585       {
98586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98587       };
98588     } catch (std::exception& e) {
98589       {
98590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98591       };
98592     } catch (Dali::DaliException e) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98595       };
98596     } catch (...) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98599       };
98600     }
98601   }
98602 }
98603
98604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98605   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98606
98607   arg1 = (Dali::Toolkit::WebView *)jarg1;
98608   {
98609     try {
98610       (arg1)->Resume();
98611     } catch (std::out_of_range& e) {
98612       {
98613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98614       };
98615     } catch (std::exception& e) {
98616       {
98617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98618       };
98619     } catch (Dali::DaliException e) {
98620       {
98621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98622       };
98623     } catch (...) {
98624       {
98625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98626       };
98627     }
98628   }
98629 }
98630
98631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98632   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98633
98634   arg1 = (Dali::Toolkit::WebView *)jarg1;
98635   {
98636     try {
98637       (arg1)->GoBack();
98638     } catch (std::out_of_range& e) {
98639       {
98640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98641       };
98642     } catch (std::exception& e) {
98643       {
98644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98645       };
98646     } catch (Dali::DaliException e) {
98647       {
98648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98649       };
98650     } catch (...) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98653       };
98654     }
98655   }
98656 }
98657
98658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98659   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98660
98661   arg1 = (Dali::Toolkit::WebView *)jarg1;
98662   {
98663     try {
98664       (arg1)->GoForward();
98665     } catch (std::out_of_range& e) {
98666       {
98667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98668       };
98669     } catch (std::exception& e) {
98670       {
98671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98672       };
98673     } catch (Dali::DaliException e) {
98674       {
98675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98676       };
98677     } catch (...) {
98678       {
98679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98680       };
98681     }
98682   }
98683 }
98684
98685 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98686   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98687   bool ret;
98688
98689   arg1 = (Dali::Toolkit::WebView *)jarg1;
98690   {
98691     try {
98692       ret = (arg1)->CanGoBack();
98693     } catch (std::out_of_range& e) {
98694       {
98695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98696       };
98697     } catch (std::exception& e) {
98698       {
98699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98700       };
98701     } catch (Dali::DaliException e) {
98702       {
98703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98704       };
98705     } catch (...) {
98706       {
98707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98708       };
98709     }
98710   }
98711   return ret;
98712 }
98713
98714 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98715   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98716   bool ret;
98717
98718   arg1 = (Dali::Toolkit::WebView *)jarg1;
98719   {
98720     try {
98721       ret = (arg1)->CanGoForward();
98722     } catch (std::out_of_range& e) {
98723       {
98724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98725       };
98726     } catch (std::exception& e) {
98727       {
98728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98729       };
98730     } catch (Dali::DaliException e) {
98731       {
98732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98733       };
98734     } catch (...) {
98735       {
98736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98737       };
98738     }
98739   }
98740   return ret;
98741 }
98742
98743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98744   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98745   std::string *arg2;
98746
98747   arg1 = (Dali::Toolkit::WebView *)jarg1;
98748   if (!jarg2) {
98749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98750     return;
98751   }
98752   std::string jarg2_str = std::string(jarg2);
98753   arg2 = &jarg2_str;
98754
98755   {
98756     try {
98757       if (jarg3) {
98758         void (*handler)(char*) = (void (*)(char*)) jarg3;
98759         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98760           handler(SWIG_csharp_string_callback(result.c_str()));
98761         });
98762       } else {
98763         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98764       }
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 void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98786 {
98787   if (!jarg2) {
98788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98789     return;
98790   }
98791
98792   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98793   std::string exposedObjectName = jarg2;
98794   void (*handler)(char*) = (void (*)(char*)) jarg3;
98795
98796   {
98797     try {
98798       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98799         handler(SWIG_csharp_string_callback(message.c_str()));
98800       });
98801     } catch (std::out_of_range& e) {
98802       {
98803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98804       };
98805     } catch (std::exception& e) {
98806       {
98807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98808       };
98809     } catch (Dali::DaliException e) {
98810       {
98811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98812       };
98813     } catch (...) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98816       };
98817     }
98818   }
98819 }
98820
98821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98822   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98823
98824   arg1 = (Dali::Toolkit::WebView *)jarg1;
98825   {
98826     try {
98827       (arg1)->ClearHistory();
98828     } catch (std::out_of_range& e) {
98829       {
98830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98831       };
98832     } catch (std::exception& e) {
98833       {
98834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98835       };
98836     } catch (Dali::DaliException e) {
98837       {
98838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98839       };
98840     } catch (...) {
98841       {
98842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98843       };
98844     }
98845   }
98846 }
98847
98848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98849   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98850
98851   arg1 = (Dali::Toolkit::WebView *)jarg1;
98852   {
98853     try {
98854       (arg1)->ClearCache();
98855     } catch (std::out_of_range& e) {
98856       {
98857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98858       };
98859     } catch (std::exception& e) {
98860       {
98861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98862       };
98863     } catch (Dali::DaliException e) {
98864       {
98865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98866       };
98867     } catch (...) {
98868       {
98869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98870       };
98871     }
98872   }
98873 }
98874
98875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98876   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98877
98878   arg1 = (Dali::Toolkit::WebView *)jarg1;
98879   {
98880     try {
98881       (arg1)->ClearCookies();
98882     } catch (std::out_of_range& e) {
98883       {
98884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98885       };
98886     } catch (std::exception& e) {
98887       {
98888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98889       };
98890     } catch (Dali::DaliException e) {
98891       {
98892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98893       };
98894     } catch (...) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98897       };
98898     }
98899   }
98900 }
98901
98902 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98903     return (Dali::Toolkit::Control *)jarg1;
98904 }
98905
98906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98907   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98908   SignalConverter::WebViewPageLoadSignal* result = NULL;
98909   {
98910     try {
98911       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98912     } catch (std::out_of_range& e) {
98913       {
98914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98915       };
98916     } catch (std::exception& e) {
98917       {
98918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (Dali::DaliException e) {
98921       {
98922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98923       };
98924     } catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930   return (void*) result;
98931 }
98932
98933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98934   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98935   SignalConverter::WebViewPageLoadSignal* result = NULL;
98936   {
98937     try {
98938       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98939     } catch (std::out_of_range& e) {
98940       {
98941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98942       };
98943     } catch (std::exception& e) {
98944       {
98945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (Dali::DaliException e) {
98948       {
98949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98950       };
98951     } catch (...) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98954       };
98955     }
98956   }
98957   return (void*) result;
98958 }
98959
98960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98961 {
98962   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98963   {
98964     try {
98965       delete object;
98966     } catch (std::out_of_range& e) {
98967       {
98968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98969       };
98970     } catch (std::exception& e) {
98971       {
98972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98973       };
98974     } catch (Dali::DaliException e) {
98975       {
98976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98977       };
98978     } catch (...) {
98979       {
98980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98981       };
98982     }
98983   }
98984 }
98985
98986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98987 {
98988   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98989   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98990   {
98991     try {
98992       proxy->Connect(callback);
98993     } catch (std::out_of_range& e) {
98994       {
98995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98996       };
98997     } catch (std::exception& e) {
98998       {
98999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99000       };
99001     } catch (Dali::DaliException e) {
99002       {
99003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99004       };
99005     } catch (...) {
99006       {
99007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99008       };
99009     }
99010   }
99011 }
99012
99013
99014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
99015   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99016   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99017   {
99018     try {
99019       proxy->Disconnect(callback);
99020     } catch (std::out_of_range& e) {
99021       {
99022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99023       };
99024     } catch (std::exception& e) {
99025       {
99026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99027       };
99028     } catch (Dali::DaliException e) {
99029       {
99030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99031       };
99032     } catch (...) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99035       };
99036     }
99037   }
99038 }
99039
99040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
99041   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99042   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
99043   {
99044     try {
99045       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
99046     } catch (std::out_of_range& e) {
99047       {
99048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99049       };
99050     } catch (std::exception& e) {
99051       {
99052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99053       };
99054     } catch (Dali::DaliException e) {
99055       {
99056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99057       };
99058     } catch (...) {
99059       {
99060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99061       };
99062     }
99063   }
99064   return (void*) result;
99065 }
99066
99067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
99068 {
99069   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99070   {
99071     try {
99072       delete object;
99073     } catch (std::out_of_range& e) {
99074       {
99075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99076       };
99077     } catch (std::exception& e) {
99078       {
99079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99080       };
99081     } catch (Dali::DaliException e) {
99082       {
99083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99084       };
99085     } catch (...) {
99086       {
99087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99088       };
99089     }
99090   }
99091 }
99092
99093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
99094 {
99095   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99096   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99097   {
99098     try {
99099       proxy->Connect(callback);
99100     } catch (std::out_of_range& e) {
99101       {
99102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99103       };
99104     } catch (std::exception& e) {
99105       {
99106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99107       };
99108     } catch (Dali::DaliException e) {
99109       {
99110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99111       };
99112     } catch (...) {
99113       {
99114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99115       };
99116     }
99117   }
99118 }
99119
99120
99121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
99122   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99123   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99124   {
99125     try {
99126       proxy->Disconnect(callback);
99127     } catch (std::out_of_range& e) {
99128       {
99129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99130       };
99131     } catch (std::exception& e) {
99132       {
99133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99134       };
99135     } catch (Dali::DaliException e) {
99136       {
99137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99138       };
99139     } catch (...) {
99140       {
99141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99142       };
99143     }
99144   }
99145 }
99146
99147 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
99148   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
99149   char * jresult = SWIG_csharp_string_callback((const char *)result);
99150   return jresult;
99151 }
99152
99153 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
99154   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
99155   return result;
99156 }
99157
99158
99159 struct NativeImageSourcePtrHandle
99160 {
99161   NativeImageSourcePtr Ptr;
99162 };
99163
99164 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
99165 {
99166   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99167   return (NativeImageInterface*)(arg1);
99168 }
99169
99170 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
99171 {
99172   void* jresult;
99173   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
99174   {
99175     try {
99176       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
99177     }
99178     catch (std::out_of_range & e) {
99179       {
99180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99181       };
99182     }
99183     catch (std::exception & e) {
99184       {
99185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99186       };
99187     }
99188     catch (Dali::DaliException e) {
99189       {
99190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99191       };
99192     }
99193     catch (...) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99196       };
99197     }
99198   }
99199   jresult = (void *)handle;
99200   return jresult;
99201 }
99202
99203 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99204 {
99205   void* jresult;
99206   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99207   jresult = (void*)( handle->Ptr.Get() );
99208   return jresult;
99209 }
99210
99211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99212   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99213   {
99214     try {
99215       delete arg1;
99216     }
99217     catch (std::out_of_range & e) {
99218       {
99219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99220       };
99221     }
99222     catch (std::exception & e) {
99223       {
99224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99225       };
99226     }
99227     catch (Dali::DaliException e) {
99228       {
99229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99230       };
99231     }
99232     catch (...) {
99233       {
99234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99235       };
99236     }
99237   }
99238 }
99239
99240 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99241 {
99242   void* jresult;
99243   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99244   uint16_t* arg2 = (uint16_t*)(jarg2);
99245   uint16_t* arg3 = (uint16_t*)(jarg3);
99246   uint16_t* arg4 = (uint16_t*)(jarg4);
99247   {
99248     try {
99249       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99250     }
99251     catch (std::out_of_range & e) {
99252       {
99253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99254       };
99255     }
99256     catch (std::exception & e) {
99257       {
99258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99259       };
99260     }
99261     catch (Dali::DaliException e) {
99262       {
99263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99264       };
99265     }
99266     catch (...) {
99267       {
99268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99269       };
99270     }
99271   }
99272   return jresult;
99273 }
99274
99275 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99276 {
99277   bool jresult;
99278   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99279
99280   {
99281     try {
99282       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99283     }
99284     catch (std::out_of_range & e) {
99285       {
99286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99287       };
99288     }
99289     catch (std::exception & e) {
99290       {
99291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99292       };
99293     }
99294     catch (Dali::DaliException e) {
99295       {
99296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99297       };
99298     }
99299     catch (...) {
99300       {
99301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99302       };
99303     }
99304   }
99305   return jresult;
99306 }
99307
99308
99309 #ifdef __cplusplus
99310 }
99311 #endif