dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429 #include <dali/devel-api/events/wheel-event-devel.h>
 430
 431 #include <dali/public-api/math/matrix.h>
 432 #include <dali/public-api/math/matrix3.h>
 433 #include <dali/public-api/math/viewport.h>
 434 #include <dali/public-api/object/property-key.h>
 435 #include <dali/devel-api/object/csharp-type-info.h>
 436 #include <dali/devel-api/object/csharp-type-registry.h>
 437
 438 #include <dali/public-api/adaptor-framework/timer.h>
 439 #include <dali/public-api/adaptor-framework/style-change.h>
 440 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 441
 442 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 458 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 459 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 460
 461 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 462 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 463 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 464
 465 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 467 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 468
 469 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 470 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 471 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 472
 473 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 474
 475 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 476 #include <dali/devel-api/adaptor-framework/image-loading.h>
 477
 478 #include <dali/public-api/events/mouse-button.h>
 479
 480 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 481 #include "web-view-signal-converter.h"
 482
 483 #include <dali/integration-api/debug.h>
 484
 485 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 486
 487 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 488
 489 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 490
 491
 492 #include <dali/devel-api/update/frame-callback-interface.h>
 493 #include <dali/devel-api/update/update-proxy.h>
 494
 495
 496 // add here SWIG version check
 497
 498 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 499 // disable Swig-dependent warnings
 500
 501 // 'identifier1' has C-linkage specified,
 502 // but returns UDT 'identifier2' which is incompatible with C
 503 #pragma warning(disable: 4190)
 504
 505 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 506 #pragma warning(disable: 4800)
 507
 508 // debug info too long etc etc
 509 #pragma warning(disable: 4786)
 510 #endif
 511
 512
 513 #include <stdexcept>
 514
 515
 516 #include <string>
 517
 518
 519 #include <vector>
 520 #include <algorithm>
 521 #include <stdexcept>
 522
 523
 524 #include <map>
 525 #include <algorithm>
 526 #include <stdexcept>
 527
 528
 529 #include <utility>
 530
 531
 532 typedef float floatp;
 533
 534 SWIGINTERN floatp *new_floatp(){
 535   return new float();
 536 }
 537 SWIGINTERN void delete_floatp(floatp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void floatp_assign(floatp *self,float value){
 541   *self = value;
 542 }
 543 SWIGINTERN float floatp_value(floatp *self){
 544   return *self;
 545 }
 546 SWIGINTERN float *floatp_cast(floatp *self){
 547   return self;
 548 }
 549 SWIGINTERN floatp *floatp_frompointer(float *t){
 550   return (floatp *) t;
 551 }
 552
 553 typedef int intp;
 554
 555 SWIGINTERN intp *new_intp(){
 556   return new int();
 557 }
 558 SWIGINTERN void delete_intp(intp *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void intp_assign(intp *self,int value){
 562   *self = value;
 563 }
 564 SWIGINTERN int intp_value(intp *self){
 565   return *self;
 566 }
 567 SWIGINTERN int *intp_cast(intp *self){
 568   return self;
 569 }
 570 SWIGINTERN intp *intp_frompointer(int *t){
 571   return (intp *) t;
 572 }
 573
 574 typedef double doublep;
 575
 576 SWIGINTERN doublep *new_doublep(){
 577   return new double();
 578 }
 579 SWIGINTERN void delete_doublep(doublep *self){
 580   if (self) delete self;
 581 }
 582 SWIGINTERN void doublep_assign(doublep *self,double value){
 583   *self = value;
 584 }
 585 SWIGINTERN double doublep_value(doublep *self){
 586   return *self;
 587 }
 588 SWIGINTERN double *doublep_cast(doublep *self){
 589   return self;
 590 }
 591 SWIGINTERN doublep *doublep_frompointer(double *t){
 592   return (doublep *) t;
 593 }
 594
 595 typedef unsigned int uintp;
 596
 597 SWIGINTERN uintp *new_uintp(){
 598   return new unsigned int();
 599 }
 600 SWIGINTERN void delete_uintp(uintp *self){
 601   if (self) delete self;
 602 }
 603 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 604   *self = value;
 605 }
 606 SWIGINTERN unsigned int uintp_value(uintp *self){
 607   return *self;
 608 }
 609 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 610   return self;
 611 }
 612 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 613   return (uintp *) t;
 614 }
 615
 616 typedef unsigned short ushortp;
 617
 618 SWIGINTERN ushortp *new_ushortp(){
 619   return new unsigned short();
 620 }
 621 SWIGINTERN void delete_ushortp(ushortp *self){
 622   if (self) delete self;
 623 }
 624 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 625   *self = value;
 626 }
 627 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 628   return *self;
 629 }
 630 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 631   return self;
 632 }
 633 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 634   return (ushortp *) t;
 635 }
 636
 637 unsigned int int_to_uint(int x) {
 638    return (unsigned int) x;
 639 }
 640
 641
 642 using namespace Dali;
 643 using namespace Dali::Toolkit;
 644
 645 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 646 {
 647   bool result = false;
 648   try
 649   {
 650     // C++ code. DALi uses Handle <-> Body design pattern.
 651     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 652     // Handles in DALi can be converted into a boolean type
 653     // to check if the handle has a valid body attached to it.
 654     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 655     if( *self )
 656     {
 657       result = true;
 658     }
 659     else
 660     {
 661       result = false;
 662     }
 663   }
 664   catch (std::out_of_range& e)
 665   {
 666     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 667     return 0;
 668   }
 669   catch (std::exception& e)
 670   {
 671     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 672     return 0;
 673   }
 674   catch (DaliException e)
 675   {
 676     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 677     return 0;
 678   }
 679   catch (...)
 680   {
 681     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 682     return 0;
 683   }
 684   return result;
 685 }
 686
 687 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 688 {
 689   bool result = false;
 690   try
 691   {
 692     // C++ code. Check if two handles reference the same implemtion
 693     if( *self == rhs)
 694     {
 695       result = true;
 696     }
 697     else
 698     {
 699       result = false;
 700     }
 701   }
 702   catch (std::out_of_range& e)
 703   {
 704     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 705     return 0;
 706   }
 707   catch (std::exception& e)
 708   {
 709     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 710     return 0;
 711   }
 712   catch (DaliException e)
 713   {
 714     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 715     return 0;
 716   }
 717   catch (...)
 718   {
 719     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 720     return 0;
 721   }
 722   return result;
 723 }
 724
 725
 726 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 727      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 728    }
 729 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){
 730      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 731    }
 732 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 733         std::vector< Dali::TouchPoint >* pv = 0;
 734         if (capacity >= 0) {
 735           pv = new std::vector< Dali::TouchPoint >();
 736           pv->reserve(capacity);
 737        } else {
 738           throw std::out_of_range("capacity");
 739        }
 740        return pv;
 741       }
 742 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 743         if (index>=0 && index<(int)self->size())
 744           return (*self)[index];
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 749         if (index>=0 && index<(int)self->size())
 750           return (*self)[index];
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 755         if (index>=0 && index<(int)self->size())
 756           (*self)[index] = val;
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 761         self->insert(self->end(), values.begin(), values.end());
 762       }
 763 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 764         if (index < 0)
 765           throw std::out_of_range("index");
 766         if (count < 0)
 767           throw std::out_of_range("count");
 768         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 769           throw std::invalid_argument("invalid range");
 770         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 773         if (index>=0 && index<(int)self->size()+1)
 774           self->insert(self->begin()+index, x);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 779         if (index>=0 && index<(int)self->size()+1)
 780           self->insert(self->begin()+index, values.begin(), values.end());
 781         else
 782           throw std::out_of_range("index");
 783       }
 784 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 785         if (index>=0 && index<(int)self->size())
 786           self->erase(self->begin() + index);
 787         else
 788           throw std::out_of_range("index");
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         self->erase(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 800         if (count < 0)
 801           throw std::out_of_range("count");
 802         return new std::vector< Dali::TouchPoint >(count, value);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 805         std::reverse(self->begin(), self->end());
 806       }
 807 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 808         if (index < 0)
 809           throw std::out_of_range("index");
 810         if (count < 0)
 811           throw std::out_of_range("count");
 812         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 813           throw std::invalid_argument("invalid range");
 814         std::reverse(self->begin()+index, self->begin()+index+count);
 815       }
 816 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 817         if (index < 0)
 818           throw std::out_of_range("index");
 819         if (index+values.size() > self->size())
 820           throw std::out_of_range("index");
 821         std::copy(values.begin(), values.end(), self->begin()+index);
 822       }
 823 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 824          return self->Empty();
 825       }
 826 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 827         return self->GetConnectionCount();
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 830           self->Connect( func );
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 833           self->Disconnect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 836           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 837 /*@SWIG@*/ self->Emit( arg );
 838       }
 839 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 840          return self->Empty();
 841       }
 842 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 843         return self->GetConnectionCount();
 844       }
 845 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 846           self->Connect( func );
 847       }
 848 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 849           self->Disconnect( func );
 850       }
 851 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 852           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 853 /*@SWIG@*/ self->Emit( arg );
 854       }
 855 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 856          return self->Empty();
 857       }
 858 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){
 859         return self->GetConnectionCount();
 860       }
 861 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 *)){
 862           self->Connect( func );
 863       }
 864 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 *)){
 865           self->Disconnect( func );
 866       }
 867 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){
 868           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 869 /*@SWIG@*/ self->Emit( arg );
 870       }
 871 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 872          return self->Empty();
 873       }
 874 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 875         return self->GetConnectionCount();
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 878           self->Connect( func );
 879       }
 880 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 881           self->Disconnect( func );
 882       }
 883 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 884           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 885 /*@SWIG@*/ self->Emit( arg );
 886       }
 887 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){
 888          return self->Empty();
 889       }
 890 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){
 891         return self->GetConnectionCount();
 892       }
 893 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 &)){
 894         self->Connect( func );
 895       }
 896 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 &)){
 897         self->Disconnect( func );
 898       }
 899 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){
 900         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg1, arg2 );
 902       }
 903 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){
 904          return self->Empty();
 905       }
 906 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){
 907         return self->GetConnectionCount();
 908       }
 909 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 &)){
 910         self->Connect( func );
 911       }
 912 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 &)){
 913         self->Disconnect( func );
 914       }
 915 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){
 916         return self->Emit( arg1, arg2 );
 917       }
 918 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){
 919          return self->Empty();
 920       }
 921 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){
 922         return self->GetConnectionCount();
 923       }
 924 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 &)){
 925         self->Connect( func );
 926       }
 927 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 &)){
 928         self->Disconnect( func );
 929       }
 930 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){
 931         return self->Emit( arg1, arg2 );
 932       }
 933 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){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940         self->Connect( func );
 941       }
 942 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 &)){
 943         self->Disconnect( func );
 944       }
 945 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){
 946         return self->Emit( arg1, arg2 );
 947       }
 948 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 949          return self->Empty();
 950       }
 951 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 952         return self->GetConnectionCount();
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 955           self->Connect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 958           self->Disconnect( func );
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 961           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg );
 963       }
 964 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 965          return self->Empty();
 966       }
 967 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){
 968         return self->GetConnectionCount();
 969       }
 970 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 &)){
 971           self->Connect( func );
 972       }
 973 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 &)){
 974           self->Disconnect( func );
 975       }
 976 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){
 977           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg );
 979       }
 980 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 981          return self->Empty();
 982       }
 983 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){
 984         return self->GetConnectionCount();
 985       }
 986 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 &)){
 987           self->Connect( func );
 988       }
 989 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 &)){
 990           self->Disconnect( func );
 991       }
 992 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){
 993           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 997          return self->Empty();
 998       }
 999 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){
1000         return self->GetConnectionCount();
1001       }
1002 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 &)){
1003           self->Connect( func );
1004       }
1005 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 &)){
1006           self->Disconnect( func );
1007       }
1008 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){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012 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){
1013          return self->Empty();
1014       }
1015 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){
1016         return self->GetConnectionCount();
1017       }
1018 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 &)){
1019         self->Connect( func );
1020       }
1021 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 &)){
1022         self->Disconnect( func );
1023       }
1024 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){
1025         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1026 /*@SWIG@*/ self->Emit( arg1, arg2 );
1027       }
1028 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){
1029          return self->Empty();
1030       }
1031 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){
1032         return self->GetConnectionCount();
1033       }
1034 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 &)){
1035         self->Connect( func );
1036       }
1037 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 &)){
1038         self->Disconnect( func );
1039       }
1040 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){
1041         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1042 /*@SWIG@*/ self->Emit( arg1, arg2 );
1043       }
1044 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){
1045          return self->Empty();
1046       }
1047 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){
1048         return self->GetConnectionCount();
1049       }
1050 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 &)){
1051         self->Connect( func );
1052       }
1053 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 &)){
1054         self->Disconnect( func );
1055       }
1056 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){
1057         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1058 /*@SWIG@*/ self->Emit( arg1, arg2 );
1059       }
1060 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){
1061          return self->Empty();
1062       }
1063 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){
1064         return self->GetConnectionCount();
1065       }
1066 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)){
1067           return self->Connect( func );
1068       }
1069 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)){
1070           self->Disconnect( func );
1071       }
1072 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){
1073           self->Emit( arg1, arg3 );
1074       }
1075 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){
1076          return self->Empty();
1077       }
1078 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){
1079         return self->GetConnectionCount();
1080       }
1081 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)){
1082           return self->Connect( func );
1083       }
1084 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)){
1085           self->Disconnect( func );
1086       }
1087 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){
1088           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1089 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1090       }
1091
1092 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1093          return self->Empty();
1094       }
1095 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1096         return self->GetConnectionCount();
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1099           self->Connect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1102           self->Disconnect( func );
1103       }
1104 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1105           return self->Emit();
1106       }
1107
1108 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1109         std::vector< unsigned int >* pv = 0;
1110         if (capacity >= 0) {
1111           pv = new std::vector< unsigned int >();
1112           pv->reserve(capacity);
1113        } else {
1114           throw std::out_of_range("capacity");
1115        }
1116        return pv;
1117       }
1118 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1119         if (index>=0 && index<(int)self->size())
1120           return (*self)[index];
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1125         if (index>=0 && index<(int)self->size())
1126           return (*self)[index];
1127         else
1128           throw std::out_of_range("index");
1129       }
1130 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1131         if (index>=0 && index<(int)self->size())
1132           (*self)[index] = val;
1133         else
1134           throw std::out_of_range("index");
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1137         self->insert(self->end(), values.begin(), values.end());
1138       }
1139 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1140         if (index < 0)
1141           throw std::out_of_range("index");
1142         if (count < 0)
1143           throw std::out_of_range("count");
1144         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1145           throw std::invalid_argument("invalid range");
1146         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1149         if (index>=0 && index<(int)self->size()+1)
1150           self->insert(self->begin()+index, x);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1155         if (index>=0 && index<(int)self->size()+1)
1156           self->insert(self->begin()+index, values.begin(), values.end());
1157         else
1158           throw std::out_of_range("index");
1159       }
1160 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1161         if (index>=0 && index<(int)self->size())
1162           self->erase(self->begin() + index);
1163         else
1164           throw std::out_of_range("index");
1165       }
1166 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1167         if (index < 0)
1168           throw std::out_of_range("index");
1169         if (count < 0)
1170           throw std::out_of_range("count");
1171         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1172           throw std::invalid_argument("invalid range");
1173         self->erase(self->begin()+index, self->begin()+index+count);
1174       }
1175 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1176         if (count < 0)
1177           throw std::out_of_range("count");
1178         return new std::vector< unsigned int >(count, value);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1181         std::reverse(self->begin(), self->end());
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         std::reverse(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1193         if (index < 0)
1194           throw std::out_of_range("index");
1195         if (index+values.size() > self->size())
1196           throw std::out_of_range("index");
1197         std::copy(values.begin(), values.end(), self->begin()+index);
1198       }
1199 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1200         return std::find(self->begin(), self->end(), value) != self->end();
1201       }
1202 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1203         int index = -1;
1204         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1205         if (it != self->end())
1206           index = (int)(it - self->begin());
1207         return index;
1208       }
1209 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1210         int index = -1;
1211         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1212         if (rit != self->rend())
1213           index = (int)(self->rend() - 1 - rit);
1214         return index;
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1217         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1218         if (it != self->end()) {
1219           self->erase(it);
1220           return true;
1221         }
1222         return false;
1223       }
1224 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){
1225         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1226         if (capacity >= 0) {
1227           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1228           pv->reserve(capacity);
1229        } else {
1230           throw std::out_of_range("capacity");
1231        }
1232        return pv;
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           return (*self)[index];
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         if (index>=0 && index<(int)self->size())
1242           return (*self)[index];
1243         else
1244           throw std::out_of_range("index");
1245       }
1246 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){
1247         if (index>=0 && index<(int)self->size())
1248           (*self)[index] = val;
1249         else
1250           throw std::out_of_range("index");
1251       }
1252 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){
1253         self->insert(self->end(), values.begin(), values.end());
1254       }
1255 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){
1256         if (index < 0)
1257           throw std::out_of_range("index");
1258         if (count < 0)
1259           throw std::out_of_range("count");
1260         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1261           throw std::invalid_argument("invalid range");
1262         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1263       }
1264 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){
1265         if (index>=0 && index<(int)self->size()+1)
1266           self->insert(self->begin()+index, x);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 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){
1271         if (index>=0 && index<(int)self->size()+1)
1272           self->insert(self->begin()+index, values.begin(), values.end());
1273         else
1274           throw std::out_of_range("index");
1275       }
1276 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){
1277         if (index>=0 && index<(int)self->size())
1278           self->erase(self->begin() + index);
1279         else
1280           throw std::out_of_range("index");
1281       }
1282 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){
1283         if (index < 0)
1284           throw std::out_of_range("index");
1285         if (count < 0)
1286           throw std::out_of_range("count");
1287         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1288           throw std::invalid_argument("invalid range");
1289         self->erase(self->begin()+index, self->begin()+index+count);
1290       }
1291 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){
1292         if (count < 0)
1293           throw std::out_of_range("count");
1294         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1295       }
1296 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){
1297         std::reverse(self->begin(), self->end());
1298       }
1299 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){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         std::reverse(self->begin()+index, self->begin()+index+count);
1307       }
1308 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){
1309         if (index < 0)
1310           throw std::out_of_range("index");
1311         if (index+values.size() > self->size())
1312           throw std::out_of_range("index");
1313         std::copy(values.begin(), values.end(), self->begin()+index);
1314       }
1315 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1316         std::vector< Dali::Actor >* pv = 0;
1317         if (capacity >= 0) {
1318           pv = new std::vector< Dali::Actor >();
1319           pv->reserve(capacity);
1320        } else {
1321           throw std::out_of_range("capacity");
1322        }
1323        return pv;
1324       }
1325 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1326         if (index>=0 && index<(int)self->size())
1327           return (*self)[index];
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1332         if (index>=0 && index<(int)self->size())
1333           return (*self)[index];
1334         else
1335           throw std::out_of_range("index");
1336       }
1337 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1338         if (index>=0 && index<(int)self->size())
1339           (*self)[index] = val;
1340         else
1341           throw std::out_of_range("index");
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1344         self->insert(self->end(), values.begin(), values.end());
1345       }
1346 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1347         if (index < 0)
1348           throw std::out_of_range("index");
1349         if (count < 0)
1350           throw std::out_of_range("count");
1351         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1352           throw std::invalid_argument("invalid range");
1353         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1356         if (index>=0 && index<(int)self->size()+1)
1357           self->insert(self->begin()+index, x);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1362         if (index>=0 && index<(int)self->size()+1)
1363           self->insert(self->begin()+index, values.begin(), values.end());
1364         else
1365           throw std::out_of_range("index");
1366       }
1367 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1368         if (index>=0 && index<(int)self->size())
1369           self->erase(self->begin() + index);
1370         else
1371           throw std::out_of_range("index");
1372       }
1373 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1374         if (index < 0)
1375           throw std::out_of_range("index");
1376         if (count < 0)
1377           throw std::out_of_range("count");
1378         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1379           throw std::invalid_argument("invalid range");
1380         self->erase(self->begin()+index, self->begin()+index+count);
1381       }
1382 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1383         if (count < 0)
1384           throw std::out_of_range("count");
1385         return new std::vector< Dali::Actor >(count, value);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1388         std::reverse(self->begin(), self->end());
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         std::reverse(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1400         if (index < 0)
1401           throw std::out_of_range("index");
1402         if (index+values.size() > self->size())
1403           throw std::out_of_range("index");
1404         std::copy(values.begin(), values.end(), self->begin()+index);
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1407          return self->Empty();
1408       }
1409 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1410         return self->GetConnectionCount();
1411       }
1412 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 &)){
1413           self->Connect( func );
1414       }
1415 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 &)){
1416           self->Disconnect( func );
1417       }
1418 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){
1419           return self->Emit( arg );
1420       }
1421 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){
1422          return self->Empty();
1423       }
1424 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){
1425         return self->GetConnectionCount();
1426       }
1427 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)){
1428         self->Connect( func );
1429       }
1430 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)){
1431         self->Disconnect( func );
1432       }
1433 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){
1434         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1435 /*@SWIG@*/ self->Emit( arg1, arg2 );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1438          return self->Empty();
1439       }
1440 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){
1441         return self->GetConnectionCount();
1442       }
1443 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)){
1444         self->Connect( func );
1445       }
1446 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)){
1447         self->Disconnect( func );
1448       }
1449 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){
1450         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1451 /*@SWIG@*/ self->Emit( arg1, arg2 );
1452       }
1453 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1454          return self->Empty();
1455       }
1456 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1457         return self->GetConnectionCount();
1458       }
1459 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)){
1460         self->Connect( func );
1461       }
1462 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)){
1463         self->Disconnect( func );
1464       }
1465 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){
1466         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1467 /*@SWIG@*/ self->Emit( arg1, arg2 );
1468       }
1469 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){
1470          return self->Empty();
1471       }
1472 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){
1473         return self->GetConnectionCount();
1474       }
1475 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)){
1476         self->Connect( func );
1477       }
1478 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)){
1479         self->Disconnect( func );
1480       }
1481 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){
1482         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1483 /*@SWIG@*/ self->Emit( arg1, arg2 );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1486          return self->Empty();
1487       }
1488 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1489         return self->GetConnectionCount();
1490       }
1491 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)){
1492           self->Connect( func );
1493       }
1494 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)){
1495           self->Disconnect( func );
1496       }
1497 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1498           return self->Emit( arg );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 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)){
1507           self->Connect( func );
1508       }
1509 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)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1513           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1514 /*@SWIG@*/ self->Emit( arg );
1515       }
1516 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){
1517          return self->Empty();
1518       }
1519 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){
1520         return self->GetConnectionCount();
1521       }
1522 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)){
1523           return self->Connect( func );
1524       }
1525 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)){
1526           self->Disconnect( func );
1527       }
1528 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){
1529           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1530 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1531       }
1532 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1533          return self->Empty();
1534       }
1535 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1536         return self->GetConnectionCount();
1537       }
1538 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)){
1539           self->Connect( func );
1540       }
1541 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)){
1542           self->Disconnect( func );
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1545           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1546 /*@SWIG@*/ self->Emit( arg );
1547       }
1548 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){
1549          return self->Empty();
1550       }
1551 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){
1552         return self->GetConnectionCount();
1553       }
1554 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)){
1555           return self->Connect( func );
1556       }
1557 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)){
1558           self->Disconnect( func );
1559       }
1560 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){
1561           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1562 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1563       }
1564 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){
1565          return self->Empty();
1566       }
1567 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){
1568         return self->GetConnectionCount();
1569       }
1570 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 &)){
1571           self->Connect( func );
1572       }
1573 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 &)){
1574           self->Disconnect( func );
1575       }
1576 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){
1577           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1578 /*@SWIG@*/ self->Emit( arg );
1579       }
1580 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1581          return self->Empty();
1582       }
1583 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){
1584         return self->GetConnectionCount();
1585       }
1586 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 &)){
1587           self->Connect( func );
1588       }
1589 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 &)){
1590           self->Disconnect( func );
1591       }
1592 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){
1593           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1594 /*@SWIG@*/ self->Emit( arg );
1595       }
1596
1597
1598 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){
1599          return self->Empty();
1600       }
1601 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){
1602         return self->GetConnectionCount();
1603       }
1604 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 &)){
1605         self->Connect( func );
1606       }
1607 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 &)){
1608         self->Disconnect( func );
1609       }
1610 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){
1611         return self->Emit( arg1, arg2 );
1612       }
1613 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1614          return self->Empty();
1615       }
1616 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1617         return self->GetConnectionCount();
1618       }
1619 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)){
1620           self->Connect( func );
1621       }
1622 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)){
1623           self->Disconnect( func );
1624       }
1625 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1626           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1627 /*@SWIG@*/ self->Emit( arg );
1628       }
1629 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1630          return self->Empty();
1631       }
1632 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1633         return self->GetConnectionCount();
1634       }
1635 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 &)){
1636           self->Connect( func );
1637       }
1638 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 &)){
1639           self->Disconnect( func );
1640       }
1641 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){
1642           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1643 /*@SWIG@*/ self->Emit( arg );
1644       }
1645 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1646          return self->Empty();
1647       }
1648 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){
1649         return self->GetConnectionCount();
1650       }
1651 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)){
1652         self->Connect( func );
1653       }
1654 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)){
1655         self->Disconnect( func );
1656       }
1657 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){
1658         return self->Emit( arg1, arg2 );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1661          return self->Empty();
1662       }
1663 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){
1664         return self->GetConnectionCount();
1665       }
1666 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)){
1667         self->Connect( func );
1668       }
1669 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)){
1670         self->Disconnect( func );
1671       }
1672 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){
1673         return self->Emit( arg1, arg2 );
1674       }
1675
1676 /* ---------------------------------------------------
1677  * C++ director class methods
1678  * --------------------------------------------------- */
1679
1680 #include "dali_wrap.h"
1681
1682 /*
1683  *  Widget director
1684  */
1685 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1686   swig_init_callbacks();
1687 }
1688
1689 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1690 }
1691
1692 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1693   char * jcontentInfo = 0 ;
1694   void * jwindow  ;
1695
1696   if (!swig_callbackOnCreate) {
1697     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1698     return;
1699   } else {
1700     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1701     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1702     swig_callbackOnCreate(jcontentInfo, jwindow);
1703   }
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1707   char * jcontentInfo = 0 ;
1708   int jtype  ;
1709
1710   if (!swig_callbackOnTerminate) {
1711     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jtype = (int)type;
1716     swig_callbackOnTerminate(jcontentInfo, jtype);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnPause() {
1721   if (!swig_callbackOnPause) {
1722     Dali::Internal::Adaptor::Widget::OnPause();
1723     return;
1724   } else {
1725     swig_callbackOnPause();
1726   }
1727 }
1728
1729 void SwigDirector_WidgetImpl::OnResume() {
1730   if (!swig_callbackOnResume) {
1731     Dali::Internal::Adaptor::Widget::OnResume();
1732     return;
1733   } else {
1734     swig_callbackOnResume();
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1739   void * jwindow  ;
1740
1741   if (!swig_callbackOnResize) {
1742     Dali::Internal::Adaptor::Widget::OnResize(window);
1743     return;
1744   } else {
1745     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1746     swig_callbackOnResize(jwindow);
1747   }
1748 }
1749
1750 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1751   char * jcontentInfo = 0 ;
1752   int jforce  ;
1753
1754   if (!swig_callbackOnUpdate) {
1755     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1756     return;
1757   } else {
1758     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1759     jforce = force;
1760     swig_callbackOnUpdate(jcontentInfo, jforce);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1765   void * jslotObserver = 0 ;
1766   void * jcallback = 0 ;
1767
1768   if (!swig_callbackSignalConnected) {
1769     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1770     return;
1771   } else {
1772     jslotObserver = (void *) slotObserver;
1773     jcallback = (void *) callback;
1774     swig_callbackSignalConnected(jslotObserver, jcallback);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalDisconnected) {
1783     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 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) {
1793
1794   swig_callbackOnCreate = callbackOnCreate;
1795   swig_callbackOnTerminate = callbackOnTerminate;
1796   swig_callbackOnPause = callbackOnPause;
1797   swig_callbackOnResume = callbackOnResume;
1798   swig_callbackOnResize = callbackOnResize;
1799   swig_callbackOnUpdate = callbackOnUpdate;
1800   swig_callbackSignalConnected = callbackSignalConnected;
1801   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1802 }
1803
1804 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1805   swig_callbackOnCreate = 0;
1806   swig_callbackOnTerminate = 0;
1807   swig_callbackOnPause = 0;
1808   swig_callbackOnResume = 0;
1809   swig_callbackOnResize = 0;
1810   swig_callbackOnUpdate = 0;
1811   swig_callbackSignalConnected = 0;
1812   swig_callbackSignalDisconnected = 0;
1813 }
1814
1815
1816 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1817   swig_init_callbacks();
1818 }
1819
1820 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1821
1822 }
1823
1824
1825 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1826   int jdepth  ;
1827
1828   if (!swig_callbackOnSceneConnection) {
1829     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1830     return;
1831   } else {
1832     jdepth = depth;
1833     swig_callbackOnSceneConnection(jdepth);
1834   }
1835 }
1836
1837 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1838   if (!swig_callbackOnSceneDisconnection) {
1839     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1840     return;
1841   } else {
1842     swig_callbackOnSceneDisconnection();
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1847   void * jchild = 0 ;
1848
1849   if (!swig_callbackOnChildAdd) {
1850     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1851     return;
1852   } else {
1853     jchild = (Dali::Actor *) &child;
1854     swig_callbackOnChildAdd(jchild);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1859   void * jchild = 0 ;
1860
1861   if (!swig_callbackOnChildRemove) {
1862     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1863     return;
1864   } else {
1865     jchild = (Dali::Actor *) &child;
1866     swig_callbackOnChildRemove(jchild);
1867   }
1868 }
1869
1870 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1871   int jindex  ;
1872   void * jpropertyValue  ;
1873
1874   if (!swig_callbackOnPropertySet) {
1875     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1876     return;
1877   } else {
1878     jindex = index;
1879     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1880     swig_callbackOnPropertySet(jindex, jpropertyValue);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1885   void * jtargetSize = 0 ;
1886
1887   if (!swig_callbackOnSizeSet) {
1888     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1889     return;
1890   } else {
1891     jtargetSize = (Dali::Vector3 *) &targetSize;
1892     swig_callbackOnSizeSet(jtargetSize);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1897   void * janimation = 0 ;
1898   void * jtargetSize = 0 ;
1899
1900   if (!swig_callbackOnSizeAnimation) {
1901     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1902     return;
1903   } else {
1904     janimation = (Dali::Animation *) &animation;
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1907   }
1908 }
1909
1910 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1911   bool c_result = SwigValueInit< bool >() ;
1912   unsigned int jresult = 0 ;
1913   void * jarg0 = 0 ;
1914
1915   if (!swig_callbackOnHoverEvent) {
1916     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1917   } else {
1918     jarg0 = (Dali::HoverEvent *) &event;
1919     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1920     c_result = jresult ? true : false;
1921   }
1922   return c_result;
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnKeyEvent) {
1931     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1932   } else {
1933     jarg0 = (Dali::KeyEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnWheelEvent) {
1946     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1947   } else {
1948     jarg0 = (Dali::WheelEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1956   void * jsize = 0 ;
1957   void * jcontainer = 0 ;
1958
1959   if (!swig_callbackOnRelayout) {
1960     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1961     return;
1962   } else {
1963     jsize = (Dali::Vector2 *) &size;
1964     jcontainer = (Dali::RelayoutContainer *) &container;
1965     swig_callbackOnRelayout(jsize, jcontainer);
1966   }
1967 }
1968
1969 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1970   int jpolicy  ;
1971   int jdimension  ;
1972
1973   if (!swig_callbackOnSetResizePolicy) {
1974     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1975     return;
1976   } else {
1977     jpolicy = (int)policy;
1978     jdimension = (int)dimension;
1979     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1980   }
1981 }
1982
1983 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1984   Dali::Vector3 c_result ;
1985   void * jresult = 0 ;
1986
1987   if (!swig_callbackGetNaturalSize) {
1988     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1989   } else {
1990     jresult = (void *) swig_callbackGetNaturalSize();
1991     if (!jresult) {
1992       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1993       return c_result;
1994     }
1995     c_result = *(Dali::Vector3 *)jresult;
1996   }
1997   return c_result;
1998 }
1999
2000 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2001   float c_result = SwigValueInit< float >() ;
2002   float jresult = 0 ;
2003   void * jchild = 0 ;
2004   int jdimension  ;
2005
2006   if (!swig_callbackCalculateChildSize) {
2007     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2008   } else {
2009     jchild = (Dali::Actor *) &child;
2010     jdimension = (int)dimension;
2011     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2012     c_result = (float)jresult;
2013   }
2014   return c_result;
2015 }
2016
2017 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2018   float c_result = SwigValueInit< float >() ;
2019   float jresult = 0 ;
2020   float jwidth  ;
2021
2022   if (!swig_callbackGetHeightForWidth) {
2023     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2024   } else {
2025     jwidth = width;
2026     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2027     c_result = (float)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   float jheight  ;
2036
2037   if (!swig_callbackGetWidthForHeight) {
2038     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2039   } else {
2040     jheight = height;
2041     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2048   bool c_result = SwigValueInit< bool >() ;
2049   unsigned int jresult = 0 ;
2050   int jdimension  ;
2051
2052   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2053     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2054   } else {
2055     jdimension = (int)dimension;
2056     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2057     c_result = jresult ? true : false;
2058   }
2059   return c_result;
2060 }
2061
2062 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2063   int jdimension  ;
2064
2065   if (!swig_callbackOnCalculateRelayoutSize) {
2066     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2067     return;
2068   } else {
2069     jdimension = (int)dimension;
2070     swig_callbackOnCalculateRelayoutSize(jdimension);
2071   }
2072 }
2073
2074 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2075   float jsize  ;
2076   int jdimension  ;
2077
2078   if (!swig_callbackOnLayoutNegotiated) {
2079     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2080     return;
2081   } else {
2082     jsize = size;
2083     jdimension = (int)dimension;
2084     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2085   }
2086 }
2087
2088 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2089   return Dali::CustomActorImpl::GetExtension();
2090 }
2091
2092 void SwigDirector_ViewImpl::OnInitialize() {
2093   if (!swig_callbackOnInitialize) {
2094     Dali::Toolkit::Internal::Control::OnInitialize();
2095     return;
2096   } else {
2097     swig_callbackOnInitialize();
2098   }
2099 }
2100
2101 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2102   void * jstyleManager  ;
2103   int jchange  ;
2104
2105   if (!swig_callbackOnStyleChange) {
2106     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2107     return;
2108   } else {
2109     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2110     jchange = (int)change;
2111     swig_callbackOnStyleChange(jstyleManager, jchange);
2112   }
2113 }
2114
2115 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2116   bool c_result = SwigValueInit< bool >() ;
2117   unsigned int jresult = 0 ;
2118
2119   if (!swig_callbackOnAccessibilityActivated) {
2120     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2121   } else {
2122     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2123     c_result = jresult ? true : false;
2124   }
2125   return c_result;
2126 }
2127
2128 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2129   bool c_result = SwigValueInit< bool >() ;
2130   unsigned int jresult = 0 ;
2131   void * jgesture  ;
2132
2133   if (!swig_callbackOnAccessibilityPan) {
2134     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2135   } else {
2136     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2137     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2138     c_result = jresult ? true : false;
2139   }
2140   return c_result;
2141 }
2142
2143 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2144   bool c_result = SwigValueInit< bool >() ;
2145   unsigned int jresult = 0 ;
2146   unsigned int jisIncrease  ;
2147
2148   if (!swig_callbackOnAccessibilityValueChange) {
2149     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2150   } else {
2151     jisIncrease = isIncrease;
2152     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2153     c_result = jresult ? true : false;
2154   }
2155   return c_result;
2156 }
2157
2158 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2159   bool c_result = SwigValueInit< bool >() ;
2160   unsigned int jresult = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityZoom) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2164   } else {
2165     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2166     c_result = jresult ? true : false;
2167   }
2168   return c_result;
2169 }
2170
2171 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2172   if (!swig_callbackOnKeyInputFocusGained) {
2173     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2174     return;
2175   } else {
2176     swig_callbackOnKeyInputFocusGained();
2177   }
2178 }
2179
2180 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2181   if (!swig_callbackOnKeyInputFocusLost) {
2182     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2183     return;
2184   } else {
2185     swig_callbackOnKeyInputFocusLost();
2186   }
2187 }
2188
2189 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2190   Dali::Actor c_result ;
2191   void * jresult = 0 ;
2192   void * jcurrentFocusedActor  ;
2193   int jdirection  ;
2194   unsigned int jloopEnabled  ;
2195
2196   if (!swig_callbackGetNextKeyboardFocusableActor) {
2197     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2198   } else {
2199     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2200     jdirection = (int)direction;
2201     jloopEnabled = loopEnabled;
2202     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2203     if (!jresult) {
2204       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2205       return c_result;
2206     }
2207     c_result = *(Dali::Actor *)jresult;
2208   }
2209   return c_result;
2210 }
2211
2212 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2213   void * jcommitedFocusableActor  ;
2214
2215   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2216     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2217     return;
2218   } else {
2219     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2220     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2221   }
2222 }
2223
2224 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2225   bool c_result = SwigValueInit< bool >() ;
2226   unsigned int jresult = 0 ;
2227
2228   if (!swig_callbackOnKeyboardEnter) {
2229     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2230   } else {
2231     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2232     c_result = jresult ? true : false;
2233   }
2234   return c_result;
2235 }
2236
2237 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2238   void * jpinch = 0 ;
2239
2240   if (!swig_callbackOnPinch) {
2241     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2242     return;
2243   } else {
2244     jpinch = (Dali::PinchGesture *) &pinch;
2245     swig_callbackOnPinch(jpinch);
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2250   void * jpan = 0 ;
2251
2252   if (!swig_callbackOnPan) {
2253     Dali::Toolkit::Internal::Control::OnPan(pan);
2254     return;
2255   } else {
2256     jpan = (Dali::PanGesture *) &pan;
2257     swig_callbackOnPan(jpan);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2262   void * jtap = 0 ;
2263
2264   if (!swig_callbackOnTap) {
2265     Dali::Toolkit::Internal::Control::OnTap(tap);
2266     return;
2267   } else {
2268     jtap = (Dali::TapGesture *) &tap;
2269     swig_callbackOnTap(jtap);
2270   }
2271 }
2272
2273 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2274   void * jlongPress = 0 ;
2275
2276   if (!swig_callbackOnLongPress) {
2277     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2278     return;
2279   } else {
2280     jlongPress = (Dali::LongPressGesture *) &longPress;
2281     swig_callbackOnLongPress(jlongPress);
2282   }
2283 }
2284
2285 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2286   void * jslotObserver = 0 ;
2287   void * jcallback = 0 ;
2288
2289   if (!swig_callbackSignalConnected) {
2290     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2291     return;
2292   } else {
2293     jslotObserver = (void *) slotObserver;
2294     jcallback = (void *) callback;
2295     swig_callbackSignalConnected(jslotObserver, jcallback);
2296   }
2297 }
2298
2299 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2300   void * jslotObserver = 0 ;
2301   void * jcallback = 0 ;
2302
2303   if (!swig_callbackSignalDisconnected) {
2304     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2305     return;
2306   } else {
2307     jslotObserver = (void *) slotObserver;
2308     jcallback = (void *) callback;
2309     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2310   }
2311 }
2312
2313 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2314   return Dali::Toolkit::Internal::Control::GetControlExtension();
2315 }
2316
2317 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) {
2318   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2319   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2320   swig_callbackOnChildAdd = callbackOnChildAdd;
2321   swig_callbackOnChildRemove = callbackOnChildRemove;
2322   swig_callbackOnPropertySet = callbackOnPropertySet;
2323   swig_callbackOnSizeSet = callbackOnSizeSet;
2324   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2325   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2326   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2327   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2328   swig_callbackOnRelayout = callbackOnRelayout;
2329   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2330   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2331   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2332   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2333   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2334   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2335   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2336   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2337   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2338   swig_callbackOnInitialize = callbackOnInitialize;
2339   swig_callbackOnStyleChange = callbackOnStyleChange;
2340   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2341   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2342   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2343   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2344   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2345   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2346   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2347   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2348   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2349   swig_callbackOnPinch = callbackOnPinch;
2350   swig_callbackOnPan = callbackOnPan;
2351   swig_callbackOnTap = callbackOnTap;
2352   swig_callbackOnLongPress = callbackOnLongPress;
2353   swig_callbackSignalConnected = callbackSignalConnected;
2354   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2355 }
2356
2357 void SwigDirector_ViewImpl::swig_init_callbacks() {
2358   swig_callbackOnSceneConnection = 0;
2359   swig_callbackOnSceneDisconnection = 0;
2360   swig_callbackOnChildAdd = 0;
2361   swig_callbackOnChildRemove = 0;
2362   swig_callbackOnPropertySet = 0;
2363   swig_callbackOnSizeSet = 0;
2364   swig_callbackOnSizeAnimation = 0;
2365   swig_callbackOnHoverEvent = 0;
2366   swig_callbackOnKeyEvent = 0;
2367   swig_callbackOnWheelEvent = 0;
2368   swig_callbackOnRelayout = 0;
2369   swig_callbackOnSetResizePolicy = 0;
2370   swig_callbackGetNaturalSize = 0;
2371   swig_callbackCalculateChildSize = 0;
2372   swig_callbackGetHeightForWidth = 0;
2373   swig_callbackGetWidthForHeight = 0;
2374   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2375   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2376   swig_callbackOnCalculateRelayoutSize = 0;
2377   swig_callbackOnLayoutNegotiated = 0;
2378   swig_callbackOnInitialize = 0;
2379   swig_callbackOnStyleChange = 0;
2380   swig_callbackOnAccessibilityActivated = 0;
2381   swig_callbackOnAccessibilityPan = 0;
2382   swig_callbackOnAccessibilityValueChange = 0;
2383   swig_callbackOnAccessibilityZoom = 0;
2384   swig_callbackOnKeyInputFocusGained = 0;
2385   swig_callbackOnKeyInputFocusLost = 0;
2386   swig_callbackGetNextKeyboardFocusableActor = 0;
2387   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2388   swig_callbackOnKeyboardEnter = 0;
2389   swig_callbackOnPinch = 0;
2390   swig_callbackOnPan = 0;
2391   swig_callbackOnTap = 0;
2392   swig_callbackOnLongPress = 0;
2393   swig_callbackSignalConnected = 0;
2394   swig_callbackSignalDisconnected = 0;
2395 }
2396
2397 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2398   swig_init_callbacks();
2399 }
2400
2401 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2402
2403 }
2404
2405
2406 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2407   unsigned int c_result = SwigValueInit< unsigned int >() ;
2408   unsigned int jresult = 0 ;
2409
2410   if (!swig_callbackGetNumberOfItems) {
2411     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2412   } else {
2413     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2414     c_result = (unsigned int)jresult;
2415   }
2416   return c_result;
2417 }
2418
2419 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2420   Dali::Actor c_result ;
2421   void * jresult = 0 ;
2422   unsigned int jitemId  ;
2423
2424   if (!swig_callbackNewItem) {
2425     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2426   } else {
2427     jitemId = itemId;
2428     jresult = (void *) swig_callbackNewItem(jitemId);
2429     if (!jresult) {
2430       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2431       return c_result;
2432     }
2433     c_result = *(Dali::Actor *)jresult;
2434   }
2435   return c_result;
2436 }
2437
2438 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2439   unsigned int jitemId  ;
2440   void * jactor  ;
2441
2442   if (!swig_callbackItemReleased) {
2443     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2444     return;
2445   } else {
2446     jitemId = itemId;
2447     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2448     swig_callbackItemReleased(jitemId, jactor);
2449   }
2450 }
2451
2452 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2453   return Dali::Toolkit::ItemFactory::GetExtension();
2454 }
2455
2456 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2457   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2458   swig_callbackNewItem = callbackNewItem;
2459   swig_callbackItemReleased = callbackItemReleased;
2460 }
2461
2462 void SwigDirector_ItemFactory::swig_init_callbacks() {
2463   swig_callbackGetNumberOfItems = 0;
2464   swig_callbackNewItem = 0;
2465   swig_callbackItemReleased = 0;
2466 }
2467
2468 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2469   swig_init_callbacks();
2470 }
2471
2472 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2473
2474 }
2475
2476
2477 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2478   Dali::Actor c_result ;
2479   void * jresult = 0 ;
2480   void * jcurrent  ;
2481   void * jproposed  ;
2482   int jdirection  ;
2483
2484   if (!swig_callbackGetNextFocusableActor) {
2485     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2486   } else {
2487     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2488     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2489     jdirection = (int)direction;
2490     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2491     if (!jresult) {
2492       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__);
2493       return c_result;
2494     }
2495     c_result = *(Dali::Actor *)jresult;
2496   }
2497   return c_result;
2498 }
2499
2500 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2501   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2502 }
2503
2504 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2505   swig_callbackGetNextFocusableActor = 0;
2506 }
2507
2508 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2509   swig_callbackOnUpdate = 0;
2510 }
2511
2512 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2513
2514 }
2515
2516 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2517   swig_callbackOnUpdate = callbackUpdate;
2518 }
2519
2520
2521 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2522   void * jcurrent  ;
2523
2524   if (!swig_callbackOnUpdate) {
2525     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2526   } else {
2527     Dali::UpdateProxy* proxy = &updateProxy;
2528     jcurrent = (void *)proxy;
2529     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2530     if (!jcurrent) {
2531       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2532       return;
2533     }
2534   }
2535   return;
2536 }
2537
2538
2539 #ifdef __cplusplus
2540 extern "C" {
2541 #endif
2542
2543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2544   void * jresult ;
2545   floatp *result = 0 ;
2546
2547   {
2548     try {
2549       result = (floatp *)new_floatp();
2550     } catch (std::out_of_range& e) {
2551       {
2552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2553       };
2554     } catch (std::exception& e) {
2555       {
2556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2557       };
2558     } catch (DaliException e) {
2559       {
2560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2561       };
2562     } catch (...) {
2563       {
2564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2565       };
2566     }
2567   }
2568   jresult = (void *)result;
2569   return jresult;
2570 }
2571
2572
2573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2574   floatp *arg1 = (floatp *) 0 ;
2575
2576   arg1 = (floatp *)jarg1;
2577   {
2578     try {
2579       delete_floatp(arg1);
2580     } catch (std::out_of_range& e) {
2581       {
2582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2583       };
2584     } catch (std::exception& e) {
2585       {
2586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2587       };
2588     } catch (Dali::DaliException e) {
2589       {
2590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2591       };
2592     } catch (...) {
2593       {
2594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2595       };
2596     }
2597   }
2598
2599 }
2600
2601
2602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2603   floatp *arg1 = (floatp *) 0 ;
2604   float arg2 ;
2605
2606   arg1 = (floatp *)jarg1;
2607   arg2 = (float)jarg2;
2608   {
2609     try {
2610       floatp_assign(arg1,arg2);
2611     } catch (std::out_of_range& e) {
2612       {
2613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2614       };
2615     } catch (std::exception& e) {
2616       {
2617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2618       };
2619     } catch (Dali::DaliException e) {
2620       {
2621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2622       };
2623     } catch (...) {
2624       {
2625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2626       };
2627     }
2628   }
2629
2630 }
2631
2632
2633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2634   float jresult ;
2635   floatp *arg1 = (floatp *) 0 ;
2636   float result;
2637
2638   arg1 = (floatp *)jarg1;
2639   {
2640     try {
2641       result = (float)floatp_value(arg1);
2642     } catch (std::out_of_range& e) {
2643       {
2644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2645       };
2646     } catch (std::exception& e) {
2647       {
2648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2649       };
2650     } catch (DaliException e) {
2651       {
2652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2653       };
2654     } catch (...) {
2655       {
2656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2657       };
2658     }
2659   }
2660   jresult = result;
2661   return jresult;
2662 }
2663
2664
2665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2666   void * jresult ;
2667   floatp *arg1 = (floatp *) 0 ;
2668   float *result = 0 ;
2669
2670   arg1 = (floatp *)jarg1;
2671   {
2672     try {
2673       result = (float *)floatp_cast(arg1);
2674     } catch (std::out_of_range& e) {
2675       {
2676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2677       };
2678     } catch (std::exception& e) {
2679       {
2680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2681       };
2682     } catch (Dali::DaliException e) {
2683       {
2684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2685       };
2686     } catch (...) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2689       };
2690     }
2691   }
2692
2693   jresult = (void *)result;
2694   return jresult;
2695 }
2696
2697
2698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2699   void * jresult ;
2700   float *arg1 = (float *) 0 ;
2701   floatp *result = 0 ;
2702
2703   arg1 = (float *)jarg1;
2704   {
2705     try {
2706       result = (floatp *)floatp_frompointer(arg1);
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2714       };
2715     } catch (Dali::DaliException e) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2718       };
2719     } catch (...) {
2720       {
2721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2722       };
2723     }
2724   }
2725
2726   jresult = (void *)result;
2727   return jresult;
2728 }
2729
2730
2731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2732   void * jresult ;
2733   intp *result = 0 ;
2734
2735   {
2736     try {
2737       result = (intp *)new_intp();
2738     } catch (std::out_of_range& e) {
2739       {
2740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2741       };
2742     } catch (std::exception& e) {
2743       {
2744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2745       };
2746     } catch (Dali::DaliException e) {
2747       {
2748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2749       };
2750     } catch (...) {
2751       {
2752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2753       };
2754     }
2755   }
2756
2757   jresult = (void *)result;
2758   return jresult;
2759 }
2760
2761
2762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2763   intp *arg1 = (intp *) 0 ;
2764
2765   arg1 = (intp *)jarg1;
2766   {
2767     try {
2768       delete_intp(arg1);
2769     } catch (std::out_of_range& e) {
2770       {
2771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2772       };
2773     } catch (std::exception& e) {
2774       {
2775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2776       };
2777     } catch (Dali::DaliException e) {
2778       {
2779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2780       };
2781     } catch (...) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2784       };
2785     }
2786   }
2787
2788 }
2789
2790
2791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2792   intp *arg1 = (intp *) 0 ;
2793   int arg2 ;
2794
2795   arg1 = (intp *)jarg1;
2796   arg2 = (int)jarg2;
2797   {
2798     try {
2799       intp_assign(arg1,arg2);
2800     } catch (std::out_of_range& e) {
2801       {
2802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2803       };
2804     } catch (std::exception& e) {
2805       {
2806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2807       };
2808     } catch (Dali::DaliException e) {
2809       {
2810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2811       };
2812     } catch (...) {
2813       {
2814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2815       };
2816     }
2817   }
2818
2819 }
2820
2821
2822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2823   int jresult ;
2824   intp *arg1 = (intp *) 0 ;
2825   int result;
2826
2827   arg1 = (intp *)jarg1;
2828   {
2829     try {
2830       result = (int)intp_value(arg1);
2831     } catch (std::out_of_range& e) {
2832       {
2833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2834       };
2835     } catch (std::exception& e) {
2836       {
2837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2838       };
2839     } catch (Dali::DaliException e) {
2840       {
2841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2842       };
2843     } catch (...) {
2844       {
2845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2846       };
2847     }
2848   }
2849
2850   jresult = result;
2851   return jresult;
2852 }
2853
2854
2855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2856   void * jresult ;
2857   intp *arg1 = (intp *) 0 ;
2858   int *result = 0 ;
2859
2860   arg1 = (intp *)jarg1;
2861   {
2862     try {
2863       result = (int *)intp_cast(arg1);
2864     } catch (std::out_of_range& e) {
2865       {
2866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2867       };
2868     } catch (std::exception& e) {
2869       {
2870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (Dali::DaliException e) {
2873       {
2874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882
2883   jresult = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2889   void * jresult ;
2890   int *arg1 = (int *) 0 ;
2891   intp *result = 0 ;
2892
2893   arg1 = (int *)jarg1;
2894   {
2895     try {
2896       result = (intp *)intp_frompointer(arg1);
2897     } catch (std::out_of_range& e) {
2898       {
2899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2900       };
2901     } catch (std::exception& e) {
2902       {
2903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2904       };
2905     } catch (Dali::DaliException e) {
2906       {
2907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2908       };
2909     } catch (...) {
2910       {
2911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2912       };
2913     }
2914   }
2915
2916   jresult = (void *)result;
2917   return jresult;
2918 }
2919
2920
2921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2922   void * jresult ;
2923   doublep *result = 0 ;
2924
2925   {
2926     try {
2927       result = (doublep *)new_doublep();
2928     } catch (std::out_of_range& e) {
2929       {
2930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2931       };
2932     } catch (std::exception& e) {
2933       {
2934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2935       };
2936     } catch (Dali::DaliException e) {
2937       {
2938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2939       };
2940     } catch (...) {
2941       {
2942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2943       };
2944     }
2945   }
2946
2947   jresult = (void *)result;
2948   return jresult;
2949 }
2950
2951
2952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2953   doublep *arg1 = (doublep *) 0 ;
2954
2955   arg1 = (doublep *)jarg1;
2956   {
2957     try {
2958       delete_doublep(arg1);
2959     } catch (std::out_of_range& e) {
2960       {
2961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2962       };
2963     } catch (std::exception& e) {
2964       {
2965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2966       };
2967     } catch (Dali::DaliException e) {
2968       {
2969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2970       };
2971     } catch (...) {
2972       {
2973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2974       };
2975     }
2976   }
2977
2978 }
2979
2980
2981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2982   doublep *arg1 = (doublep *) 0 ;
2983   double arg2 ;
2984
2985   arg1 = (doublep *)jarg1;
2986   arg2 = (double)jarg2;
2987   {
2988     try {
2989       doublep_assign(arg1,arg2);
2990     } catch (std::out_of_range& e) {
2991       {
2992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2993       };
2994     } catch (std::exception& e) {
2995       {
2996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2997       };
2998     } catch (Dali::DaliException e) {
2999       {
3000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3001       };
3002     } catch (...) {
3003       {
3004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3005       };
3006     }
3007   }
3008
3009 }
3010
3011
3012 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3013   double jresult ;
3014   doublep *arg1 = (doublep *) 0 ;
3015   double result;
3016
3017   arg1 = (doublep *)jarg1;
3018   {
3019     try {
3020       result = (double)doublep_value(arg1);
3021     } catch (std::out_of_range& e) {
3022       {
3023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3024       };
3025     } catch (std::exception& e) {
3026       {
3027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (Dali::DaliException e) {
3030       {
3031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3032       };
3033     } catch (...) {
3034       {
3035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3036       };
3037     }
3038   }
3039
3040   jresult = result;
3041   return jresult;
3042 }
3043
3044
3045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3046   void * jresult ;
3047   doublep *arg1 = (doublep *) 0 ;
3048   double *result = 0 ;
3049
3050   arg1 = (doublep *)jarg1;
3051   {
3052     try {
3053       result = (double *)doublep_cast(arg1);
3054     } catch (std::out_of_range& e) {
3055       {
3056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3057       };
3058     } catch (std::exception& e) {
3059       {
3060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3061       };
3062     } catch (Dali::DaliException e) {
3063       {
3064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3065       };
3066     } catch (...) {
3067       {
3068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3069       };
3070     }
3071   }
3072
3073   jresult = (void *)result;
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3079   void * jresult ;
3080   double *arg1 = (double *) 0 ;
3081   doublep *result = 0 ;
3082
3083   arg1 = (double *)jarg1;
3084   {
3085     try {
3086       result = (doublep *)doublep_frompointer(arg1);
3087     } catch (std::out_of_range& e) {
3088       {
3089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3090       };
3091     } catch (std::exception& e) {
3092       {
3093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3094       };
3095     } catch (Dali::DaliException e) {
3096       {
3097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3098       };
3099     } catch (...) {
3100       {
3101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3102       };
3103     }
3104   }
3105
3106   jresult = (void *)result;
3107   return jresult;
3108 }
3109
3110
3111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3112   void * jresult ;
3113   uintp *result = 0 ;
3114
3115   {
3116     try {
3117       result = (uintp *)new_uintp();
3118     } catch (std::out_of_range& e) {
3119       {
3120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3121       };
3122     } catch (std::exception& e) {
3123       {
3124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3125       };
3126     } catch (Dali::DaliException e) {
3127       {
3128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3129       };
3130     } catch (...) {
3131       {
3132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3133       };
3134     }
3135   }
3136
3137   jresult = (void *)result;
3138   return jresult;
3139 }
3140
3141
3142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3143   uintp *arg1 = (uintp *) 0 ;
3144
3145   arg1 = (uintp *)jarg1;
3146   {
3147     try {
3148       delete_uintp(arg1);
3149     } catch (std::out_of_range& e) {
3150       {
3151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3152       };
3153     } catch (std::exception& e) {
3154       {
3155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3156       };
3157     } catch (Dali::DaliException e) {
3158       {
3159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3160       };
3161     } catch (...) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3164       };
3165     }
3166   }
3167
3168 }
3169
3170
3171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3172   uintp *arg1 = (uintp *) 0 ;
3173   unsigned int arg2 ;
3174
3175   arg1 = (uintp *)jarg1;
3176   arg2 = (unsigned int)jarg2;
3177   {
3178     try {
3179       uintp_assign(arg1,arg2);
3180     } catch (std::out_of_range& e) {
3181       {
3182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3183       };
3184     } catch (std::exception& e) {
3185       {
3186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3187       };
3188     } catch (Dali::DaliException e) {
3189       {
3190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3191       };
3192     } catch (...) {
3193       {
3194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3195       };
3196     }
3197   }
3198
3199 }
3200
3201
3202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3203   unsigned int jresult ;
3204   uintp *arg1 = (uintp *) 0 ;
3205   unsigned int result;
3206
3207   arg1 = (uintp *)jarg1;
3208   {
3209     try {
3210       result = (unsigned int)uintp_value(arg1);
3211     } catch (std::out_of_range& e) {
3212       {
3213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3214       };
3215     } catch (std::exception& e) {
3216       {
3217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3218       };
3219     } catch (Dali::DaliException e) {
3220       {
3221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3222       };
3223     } catch (...) {
3224       {
3225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3226       };
3227     }
3228   }
3229
3230   jresult = result;
3231   return jresult;
3232 }
3233
3234
3235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3236   void * jresult ;
3237   uintp *arg1 = (uintp *) 0 ;
3238   unsigned int *result = 0 ;
3239
3240   arg1 = (uintp *)jarg1;
3241   {
3242     try {
3243       result = (unsigned int *)uintp_cast(arg1);
3244     } catch (std::out_of_range& e) {
3245       {
3246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (std::exception& e) {
3249       {
3250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3251       };
3252     } catch (Dali::DaliException e) {
3253       {
3254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3255       };
3256     } catch (...) {
3257       {
3258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3259       };
3260     }
3261   }
3262
3263   jresult = (void *)result;
3264   return jresult;
3265 }
3266
3267
3268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3269   void * jresult ;
3270   unsigned int *arg1 = (unsigned int *) 0 ;
3271   uintp *result = 0 ;
3272
3273   arg1 = (unsigned int *)jarg1;
3274   {
3275     try {
3276       result = (uintp *)uintp_frompointer(arg1);
3277     } catch (std::out_of_range& e) {
3278       {
3279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3280       };
3281     } catch (std::exception& e) {
3282       {
3283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3284       };
3285     } catch (Dali::DaliException e) {
3286       {
3287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3288       };
3289     } catch (...) {
3290       {
3291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3292       };
3293     }
3294   }
3295
3296   jresult = (void *)result;
3297   return jresult;
3298 }
3299
3300
3301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3302   void * jresult ;
3303   ushortp *result = 0 ;
3304
3305   {
3306     try {
3307       result = (ushortp *)new_ushortp();
3308     } catch (std::out_of_range& e) {
3309       {
3310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3311       };
3312     } catch (std::exception& e) {
3313       {
3314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3315       };
3316     } catch (Dali::DaliException e) {
3317       {
3318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3319       };
3320     } catch (...) {
3321       {
3322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3323       };
3324     }
3325   }
3326
3327   jresult = (void *)result;
3328   return jresult;
3329 }
3330
3331
3332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3333   ushortp *arg1 = (ushortp *) 0 ;
3334
3335   arg1 = (ushortp *)jarg1;
3336   {
3337     try {
3338       delete_ushortp(arg1);
3339     } catch (std::out_of_range& e) {
3340       {
3341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3342       };
3343     } catch (std::exception& e) {
3344       {
3345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3346       };
3347     } catch (Dali::DaliException e) {
3348       {
3349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3350       };
3351     } catch (...) {
3352       {
3353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3354       };
3355     }
3356   }
3357
3358 }
3359
3360
3361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3362   ushortp *arg1 = (ushortp *) 0 ;
3363   unsigned short arg2 ;
3364
3365   arg1 = (ushortp *)jarg1;
3366   arg2 = (unsigned short)jarg2;
3367   {
3368     try {
3369       ushortp_assign(arg1,arg2);
3370     } catch (std::out_of_range& e) {
3371       {
3372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3373       };
3374     } catch (std::exception& e) {
3375       {
3376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3377       };
3378     } catch (Dali::DaliException e) {
3379       {
3380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3385       };
3386     }
3387   }
3388
3389 }
3390
3391
3392 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3393   unsigned short jresult ;
3394   ushortp *arg1 = (ushortp *) 0 ;
3395   unsigned short result;
3396
3397   arg1 = (ushortp *)jarg1;
3398   {
3399     try {
3400       result = (unsigned short)ushortp_value(arg1);
3401     } catch (std::out_of_range& e) {
3402       {
3403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3404       };
3405     } catch (std::exception& e) {
3406       {
3407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3408       };
3409     } catch (Dali::DaliException e) {
3410       {
3411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3412       };
3413     } catch (...) {
3414       {
3415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3416       };
3417     }
3418   }
3419
3420   jresult = result;
3421   return jresult;
3422 }
3423
3424
3425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3426   void * jresult ;
3427   ushortp *arg1 = (ushortp *) 0 ;
3428   unsigned short *result = 0 ;
3429
3430   arg1 = (ushortp *)jarg1;
3431   {
3432     try {
3433       result = (unsigned short *)ushortp_cast(arg1);
3434     } catch (std::out_of_range& e) {
3435       {
3436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3437       };
3438     } catch (std::exception& e) {
3439       {
3440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3441       };
3442     } catch (Dali::DaliException e) {
3443       {
3444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3445       };
3446     } catch (...) {
3447       {
3448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3449       };
3450     }
3451   }
3452
3453   jresult = (void *)result;
3454   return jresult;
3455 }
3456
3457
3458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3459   void * jresult ;
3460   unsigned short *arg1 = (unsigned short *) 0 ;
3461   ushortp *result = 0 ;
3462
3463   arg1 = (unsigned short *)jarg1;
3464   {
3465     try {
3466       result = (ushortp *)ushortp_frompointer(arg1);
3467     } catch (std::out_of_range& e) {
3468       {
3469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3470       };
3471     } catch (std::exception& e) {
3472       {
3473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3474       };
3475     } catch (Dali::DaliException e) {
3476       {
3477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3478       };
3479     } catch (...) {
3480       {
3481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3482       };
3483     }
3484   }
3485
3486   jresult = (void *)result;
3487   return jresult;
3488 }
3489
3490
3491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3492   unsigned int jresult ;
3493   int arg1 ;
3494   unsigned int result;
3495
3496   arg1 = (int)jarg1;
3497   {
3498     try {
3499       result = (unsigned int)int_to_uint(arg1);
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (Dali::DaliException e) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3511       };
3512     } catch (...) {
3513       {
3514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3515       };
3516     }
3517   }
3518
3519   jresult = result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3525   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3526
3527   arg1 = (Dali::RefObject *)jarg1;
3528   {
3529     try {
3530       (arg1)->Reference();
3531     } catch (std::out_of_range& e) {
3532       {
3533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3534       };
3535     } catch (std::exception& e) {
3536       {
3537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3538       };
3539     } catch (Dali::DaliException e) {
3540       {
3541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3542       };
3543     } catch (...) {
3544       {
3545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3546       };
3547     }
3548   }
3549
3550 }
3551
3552
3553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3554   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3555
3556   arg1 = (Dali::RefObject *)jarg1;
3557   {
3558     try {
3559       (arg1)->Unreference();
3560     } catch (std::out_of_range& e) {
3561       {
3562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3563       };
3564     } catch (std::exception& e) {
3565       {
3566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3567       };
3568     } catch (Dali::DaliException e) {
3569       {
3570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3575       };
3576     }
3577   }
3578
3579 }
3580
3581
3582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3583   int jresult ;
3584   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3585   int result;
3586
3587   arg1 = (Dali::RefObject *)jarg1;
3588   {
3589     try {
3590       result = (int)(arg1)->ReferenceCount();
3591     } catch (std::out_of_range& e) {
3592       {
3593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3594       };
3595     } catch (std::exception& e) {
3596       {
3597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3598       };
3599     } catch (Dali::DaliException e) {
3600       {
3601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3602       };
3603     } catch (...) {
3604       {
3605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3606       };
3607     }
3608   }
3609
3610   jresult = result;
3611   return jresult;
3612 }
3613
3614
3615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3616   void * jresult ;
3617   Dali::Any *result = 0 ;
3618
3619   {
3620     try {
3621       result = (Dali::Any *)new Dali::Any();
3622     } catch (std::out_of_range& e) {
3623       {
3624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3625       };
3626     } catch (std::exception& e) {
3627       {
3628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3629       };
3630     } catch (Dali::DaliException e) {
3631       {
3632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3633       };
3634     } catch (...) {
3635       {
3636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3637       };
3638     }
3639   }
3640
3641   jresult = (void *)result;
3642   return jresult;
3643 }
3644
3645
3646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3647   Dali::Any *arg1 = (Dali::Any *) 0 ;
3648
3649   arg1 = (Dali::Any *)jarg1;
3650   {
3651     try {
3652       delete arg1;
3653     } catch (std::out_of_range& e) {
3654       {
3655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3656       };
3657     } catch (std::exception& e) {
3658       {
3659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3660       };
3661     } catch (Dali::DaliException e) {
3662       {
3663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3664       };
3665     } catch (...) {
3666       {
3667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3668       };
3669     }
3670   }
3671
3672 }
3673
3674
3675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3676   char *arg1 = (char *) 0 ;
3677
3678   arg1 = (char *)jarg1;
3679   {
3680     try {
3681       Dali::Any::AssertAlways((char const *)arg1);
3682     } catch (std::out_of_range& e) {
3683       {
3684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3685       };
3686     } catch (std::exception& e) {
3687       {
3688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3689       };
3690     } catch (Dali::DaliException e) {
3691       {
3692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3693       };
3694     } catch (...) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3697       };
3698     }
3699   }
3700
3701 }
3702
3703
3704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3705   void * jresult ;
3706   Dali::Any *arg1 = 0 ;
3707   Dali::Any *result = 0 ;
3708
3709   arg1 = (Dali::Any *)jarg1;
3710   if (!arg1) {
3711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3712     return 0;
3713   }
3714   {
3715     try {
3716       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3717     } catch (std::out_of_range& e) {
3718       {
3719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3720       };
3721     } catch (std::exception& e) {
3722       {
3723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3724       };
3725     } catch (Dali::DaliException e) {
3726       {
3727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3728       };
3729     } catch (...) {
3730       {
3731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3732       };
3733     }
3734   }
3735
3736   jresult = (void *)result;
3737   return jresult;
3738 }
3739
3740
3741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3742   void * jresult ;
3743   Dali::Any *arg1 = (Dali::Any *) 0 ;
3744   Dali::Any *arg2 = 0 ;
3745   Dali::Any *result = 0 ;
3746
3747   arg1 = (Dali::Any *)jarg1;
3748   arg2 = (Dali::Any *)jarg2;
3749   if (!arg2) {
3750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3751     return 0;
3752   }
3753   {
3754     try {
3755       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3756     } catch (std::out_of_range& e) {
3757       {
3758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3759       };
3760     } catch (std::exception& e) {
3761       {
3762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3763       };
3764     } catch (Dali::DaliException e) {
3765       {
3766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3767       };
3768     } catch (...) {
3769       {
3770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3771       };
3772     }
3773   }
3774
3775   jresult = (void *)result;
3776   return jresult;
3777 }
3778
3779
3780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3781   void * jresult ;
3782   Dali::Any *arg1 = (Dali::Any *) 0 ;
3783   std::type_info *result = 0 ;
3784
3785   arg1 = (Dali::Any *)jarg1;
3786   {
3787     try {
3788       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3789     } catch (std::out_of_range& e) {
3790       {
3791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3792       };
3793     } catch (std::exception& e) {
3794       {
3795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3796       };
3797     } catch (Dali::DaliException e) {
3798       {
3799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3800       };
3801     } catch (...) {
3802       {
3803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3804       };
3805     }
3806   }
3807
3808   jresult = (void *)result;
3809   return jresult;
3810 }
3811
3812
3813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3814   unsigned int jresult ;
3815   Dali::Any *arg1 = (Dali::Any *) 0 ;
3816   bool result;
3817
3818   arg1 = (Dali::Any *)jarg1;
3819   {
3820     try {
3821       result = (bool)((Dali::Any const *)arg1)->Empty();
3822     } catch (std::out_of_range& e) {
3823       {
3824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3825       };
3826     } catch (std::exception& e) {
3827       {
3828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3829       };
3830     } catch (Dali::DaliException e) {
3831       {
3832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3833       };
3834     } catch (...) {
3835       {
3836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3837       };
3838     }
3839   }
3840
3841   jresult = result;
3842   return jresult;
3843 }
3844
3845
3846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3847   void * jresult ;
3848   std::type_info *arg1 = 0 ;
3849   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3850   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3851   Dali::Any::AnyContainerBase *result = 0 ;
3852
3853   arg1 = (std::type_info *)jarg1;
3854   if (!arg1) {
3855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3856     return 0;
3857   }
3858   arg2 = (Dali::Any::CloneFunc)jarg2;
3859   arg3 = (Dali::Any::DeleteFunc)jarg3;
3860   {
3861     try {
3862       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3863     } catch (std::out_of_range& e) {
3864       {
3865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3866       };
3867     } catch (std::exception& e) {
3868       {
3869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3870       };
3871     } catch (Dali::DaliException e) {
3872       {
3873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3874       };
3875     } catch (...) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3878       };
3879     }
3880   }
3881
3882   jresult = (void *)result;
3883   return jresult;
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3888   void * jresult ;
3889   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3890   std::type_info *result = 0 ;
3891
3892   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3893   {
3894     try {
3895       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3896     } catch (std::out_of_range& e) {
3897       {
3898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3899       };
3900     } catch (std::exception& e) {
3901       {
3902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3903       };
3904     } catch (Dali::DaliException e) {
3905       {
3906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3907       };
3908     } catch (...) {
3909       {
3910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3911       };
3912     }
3913   }
3914
3915   jresult = (void *)result;
3916   return jresult;
3917 }
3918
3919
3920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3921   void * jresult ;
3922   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3923   ::std::type_info *result = 0 ;
3924
3925   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3926   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3927   jresult = (void *)result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3933   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3934   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3935
3936   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3937   arg2 = (Dali::Any::CloneFunc)jarg2;
3938   if (arg1) (arg1)->mCloneFunc = arg2;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3943   void * jresult ;
3944   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3945   Dali::Any::CloneFunc result;
3946
3947   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3948   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3949   jresult = (void *)result;
3950   return jresult;
3951 }
3952
3953
3954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3955   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3956   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3957
3958   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3959   arg2 = (Dali::Any::DeleteFunc)jarg2;
3960   if (arg1) (arg1)->mDeleteFunc = arg2;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3965   void * jresult ;
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   Dali::Any::DeleteFunc result;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   {
3981     try {
3982       delete arg1;
3983     } catch (std::out_of_range& e) {
3984       {
3985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3986       };
3987     } catch (std::exception& e) {
3988       {
3989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3990       };
3991     } catch (Dali::DaliException e) {
3992       {
3993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3994       };
3995     } catch (...) {
3996       {
3997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3998       };
3999     }
4000   }
4001
4002 }
4003
4004
4005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4006   Dali::Any *arg1 = (Dali::Any *) 0 ;
4007   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4008
4009   arg1 = (Dali::Any *)jarg1;
4010   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4011   if (arg1) (arg1)->mContainer = arg2;
4012 }
4013
4014
4015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4016   void * jresult ;
4017   Dali::Any *arg1 = (Dali::Any *) 0 ;
4018   Dali::Any::AnyContainerBase *result = 0 ;
4019
4020   arg1 = (Dali::Any *)jarg1;
4021   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4022   jresult = (void *)result;
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4028   char *arg1 = (char *) 0 ;
4029   char *arg2 = (char *) 0 ;
4030
4031   arg1 = (char *)jarg1;
4032   arg2 = (char *)jarg2;
4033   {
4034     try {
4035       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4036     } catch (std::out_of_range& e) {
4037       {
4038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (std::exception& e) {
4041       {
4042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4043       };
4044     } catch (Dali::DaliException e) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4047       };
4048     } catch (...) {
4049       {
4050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4051       };
4052     }
4053   }
4054
4055 }
4056
4057
4058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4059   void * jresult ;
4060   char *arg1 = (char *) 0 ;
4061   char *arg2 = (char *) 0 ;
4062   Dali::DaliException *result = 0 ;
4063
4064   arg1 = (char *)jarg1;
4065   arg2 = (char *)jarg2;
4066   {
4067     try {
4068       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4069     } catch (std::out_of_range& e) {
4070       {
4071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4072       };
4073     } catch (std::exception& e) {
4074       {
4075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4076       };
4077     } catch (Dali::DaliException e) {
4078       {
4079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4080       };
4081     } catch (...) {
4082       {
4083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4084       };
4085     }
4086   }
4087
4088   jresult = (void *)result;
4089   return jresult;
4090 }
4091
4092
4093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4094   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4095   std::string arg2 = std::string(jarg2);
4096
4097   arg1 = (Dali::DaliException *)jarg1;
4098   {
4099     if (!arg2.empty()) {
4100       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4101     } else {
4102       arg1->location = 0;
4103     }
4104   }
4105 }
4106
4107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4108   char * jresult ;
4109   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4110   char *result = 0 ;
4111
4112   arg1 = (Dali::DaliException *)jarg1;
4113   result = (char *) ((arg1)->location);
4114   jresult = SWIG_csharp_string_callback((const char *)result);
4115   return jresult;
4116 }
4117
4118
4119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4120   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4121   std::string arg2 = std::string(jarg2);
4122
4123   arg1 = (Dali::DaliException *)jarg1;
4124   {
4125     if (!arg2.empty()) {
4126       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4127     } else {
4128       arg1->condition = 0;
4129     }
4130   }
4131 }
4132
4133
4134 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4135   char * jresult ;
4136   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4137   char *result = 0 ;
4138
4139   arg1 = (Dali::DaliException *)jarg1;
4140   result = (char *) ((arg1)->condition);
4141   jresult = SWIG_csharp_string_callback((const char *)result);
4142   return jresult;
4143 }
4144
4145
4146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4147   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4148
4149   arg1 = (Dali::DaliException *)jarg1;
4150   {
4151     try {
4152       delete arg1;
4153     } catch (std::out_of_range& e) {
4154       {
4155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4156       };
4157     } catch (std::exception& e) {
4158       {
4159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4160       };
4161     } catch (Dali::DaliException e) {
4162       {
4163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4164       };
4165     } catch (...) {
4166       {
4167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4168       };
4169     }
4170   }
4171
4172 }
4173
4174
4175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4176   void * jresult ;
4177   Dali::Vector2 *result = 0 ;
4178
4179   {
4180     try {
4181       result = (Dali::Vector2 *)new Dali::Vector2();
4182     } catch (std::out_of_range& e) {
4183       {
4184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (std::exception& e) {
4187       {
4188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4189       };
4190     } catch (Dali::DaliException e) {
4191       {
4192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4193       };
4194     } catch (...) {
4195       {
4196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4197       };
4198     }
4199   }
4200
4201   jresult = (void *)result;
4202   return jresult;
4203 }
4204
4205
4206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4207   void * jresult ;
4208   float arg1 ;
4209   float arg2 ;
4210   Dali::Vector2 *result = 0 ;
4211
4212   arg1 = (float)jarg1;
4213   arg2 = (float)jarg2;
4214   {
4215     try {
4216       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4217     } catch (std::out_of_range& e) {
4218       {
4219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4220       };
4221     } catch (std::exception& e) {
4222       {
4223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4224       };
4225     } catch (Dali::DaliException e) {
4226       {
4227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4228       };
4229     } catch (...) {
4230       {
4231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4232       };
4233     }
4234   }
4235
4236   jresult = (void *)result;
4237   return jresult;
4238 }
4239
4240
4241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4242   void * jresult ;
4243   float *arg1 = (float *) 0 ;
4244   Dali::Vector2 *result = 0 ;
4245
4246   arg1 = jarg1;
4247   {
4248     try {
4249       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4250     } catch (std::out_of_range& e) {
4251       {
4252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (std::exception& e) {
4255       {
4256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4257       };
4258     } catch (Dali::DaliException e) {
4259       {
4260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4261       };
4262     } catch (...) {
4263       {
4264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4265       };
4266     }
4267   }
4268
4269   jresult = (void *)result;
4270
4271
4272   return jresult;
4273 }
4274
4275
4276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4277   void * jresult ;
4278   Dali::Vector3 *arg1 = 0 ;
4279   Dali::Vector2 *result = 0 ;
4280
4281   arg1 = (Dali::Vector3 *)jarg1;
4282   if (!arg1) {
4283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4284     return 0;
4285   }
4286   {
4287     try {
4288       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4289     } catch (std::out_of_range& e) {
4290       {
4291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4292       };
4293     } catch (std::exception& e) {
4294       {
4295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4296       };
4297     } catch (Dali::DaliException e) {
4298       {
4299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4300       };
4301     } catch (...) {
4302       {
4303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4304       };
4305     }
4306   }
4307
4308   jresult = (void *)result;
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4314   void * jresult ;
4315   Dali::Vector4 *arg1 = 0 ;
4316   Dali::Vector2 *result = 0 ;
4317
4318   arg1 = (Dali::Vector4 *)jarg1;
4319   if (!arg1) {
4320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4321     return 0;
4322   }
4323   {
4324     try {
4325       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4326     } catch (std::out_of_range& e) {
4327       {
4328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4329       };
4330     } catch (std::exception& e) {
4331       {
4332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (Dali::DaliException e) {
4335       {
4336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4337       };
4338     } catch (...) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4341       };
4342     }
4343   }
4344
4345   jresult = (void *)result;
4346   return jresult;
4347 }
4348
4349
4350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4351   void * jresult ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4361   void * jresult ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4365   jresult = (void *)result;
4366   return jresult;
4367 }
4368
4369
4370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4371   void * jresult ;
4372   Dali::Vector2 *result = 0 ;
4373
4374   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4375   jresult = (void *)result;
4376   return jresult;
4377 }
4378
4379
4380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4381   void * jresult ;
4382   Dali::Vector2 *result = 0 ;
4383
4384   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4385   jresult = (void *)result;
4386   return jresult;
4387 }
4388
4389
4390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4391   void * jresult ;
4392   Dali::Vector2 *result = 0 ;
4393
4394   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4395   jresult = (void *)result;
4396   return jresult;
4397 }
4398
4399
4400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4401   void * jresult ;
4402   Dali::Vector2 *result = 0 ;
4403
4404   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4405   jresult = (void *)result;
4406   return jresult;
4407 }
4408
4409
4410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4411   void * jresult ;
4412   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4413   float *arg2 = (float *) 0 ;
4414   Dali::Vector2 *result = 0 ;
4415
4416   arg1 = (Dali::Vector2 *)jarg1;
4417   arg2 = jarg2;
4418   {
4419     try {
4420       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4421     } catch (std::out_of_range& e) {
4422       {
4423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4424       };
4425     } catch (std::exception& e) {
4426       {
4427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4428       };
4429     } catch (Dali::DaliException e) {
4430       {
4431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4432       };
4433     } catch (...) {
4434       {
4435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4436       };
4437     }
4438   }
4439
4440   jresult = (void *)result;
4441
4442
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4448   void * jresult ;
4449   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4450   Dali::Vector3 *arg2 = 0 ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   arg1 = (Dali::Vector2 *)jarg1;
4454   arg2 = (Dali::Vector3 *)jarg2;
4455   if (!arg2) {
4456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4457     return 0;
4458   }
4459   {
4460     try {
4461       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4462     } catch (std::out_of_range& e) {
4463       {
4464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4465       };
4466     } catch (std::exception& e) {
4467       {
4468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4469       };
4470     } catch (Dali::DaliException e) {
4471       {
4472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4473       };
4474     } catch (...) {
4475       {
4476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4477       };
4478     }
4479   }
4480
4481   jresult = (void *)result;
4482   return jresult;
4483 }
4484
4485
4486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4487   void * jresult ;
4488   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4489   Dali::Vector4 *arg2 = 0 ;
4490   Dali::Vector2 *result = 0 ;
4491
4492   arg1 = (Dali::Vector2 *)jarg1;
4493   arg2 = (Dali::Vector4 *)jarg2;
4494   if (!arg2) {
4495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4496     return 0;
4497   }
4498   {
4499     try {
4500       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4501     } catch (std::out_of_range& e) {
4502       {
4503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4504       };
4505     } catch (std::exception& e) {
4506       {
4507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4508       };
4509     } catch (Dali::DaliException e) {
4510       {
4511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4512       };
4513     } catch (...) {
4514       {
4515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4516       };
4517     }
4518   }
4519
4520   jresult = (void *)result;
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4526   void * jresult ;
4527   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4528   Dali::Vector2 *arg2 = 0 ;
4529   Dali::Vector2 result;
4530
4531   arg1 = (Dali::Vector2 *)jarg1;
4532   arg2 = (Dali::Vector2 *)jarg2;
4533   if (!arg2) {
4534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4535     return 0;
4536   }
4537   {
4538     try {
4539       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4540     } catch (std::out_of_range& e) {
4541       {
4542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4543       };
4544     } catch (std::exception& e) {
4545       {
4546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (Dali::DaliException e) {
4549       {
4550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4551       };
4552     } catch (...) {
4553       {
4554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4555       };
4556     }
4557   }
4558
4559   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4560   return jresult;
4561 }
4562
4563
4564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4565   void * jresult ;
4566   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4567   Dali::Vector2 *arg2 = 0 ;
4568   Dali::Vector2 *result = 0 ;
4569
4570   arg1 = (Dali::Vector2 *)jarg1;
4571   arg2 = (Dali::Vector2 *)jarg2;
4572   if (!arg2) {
4573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4574     return 0;
4575   }
4576   {
4577     try {
4578       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4579     } catch (std::out_of_range& e) {
4580       {
4581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4582       };
4583     } catch (std::exception& e) {
4584       {
4585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (Dali::DaliException e) {
4588       {
4589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4590       };
4591     } catch (...) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4594       };
4595     }
4596   }
4597
4598   jresult = (void *)result;
4599   return jresult;
4600 }
4601
4602
4603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4604   void * jresult ;
4605   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4606   Dali::Vector2 *arg2 = 0 ;
4607   Dali::Vector2 result;
4608
4609   arg1 = (Dali::Vector2 *)jarg1;
4610   arg2 = (Dali::Vector2 *)jarg2;
4611   if (!arg2) {
4612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4613     return 0;
4614   }
4615   {
4616     try {
4617       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4618     } catch (std::out_of_range& e) {
4619       {
4620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4621       };
4622     } catch (std::exception& e) {
4623       {
4624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4625       };
4626     } catch (Dali::DaliException e) {
4627       {
4628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4629       };
4630     } catch (...) {
4631       {
4632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4633       };
4634     }
4635   }
4636
4637   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4638   return jresult;
4639 }
4640
4641
4642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4643   void * jresult ;
4644   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4645   Dali::Vector2 *arg2 = 0 ;
4646   Dali::Vector2 *result = 0 ;
4647
4648   arg1 = (Dali::Vector2 *)jarg1;
4649   arg2 = (Dali::Vector2 *)jarg2;
4650   if (!arg2) {
4651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4652     return 0;
4653   }
4654   {
4655     try {
4656       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4657     } catch (std::out_of_range& e) {
4658       {
4659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4660       };
4661     } catch (std::exception& e) {
4662       {
4663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4664       };
4665     } catch (Dali::DaliException e) {
4666       {
4667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4668       };
4669     } catch (...) {
4670       {
4671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4672       };
4673     }
4674   }
4675
4676   jresult = (void *)result;
4677   return jresult;
4678 }
4679
4680
4681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4682   void * jresult ;
4683   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4684   Dali::Vector2 *arg2 = 0 ;
4685   Dali::Vector2 result;
4686
4687   arg1 = (Dali::Vector2 *)jarg1;
4688   arg2 = (Dali::Vector2 *)jarg2;
4689   if (!arg2) {
4690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4691     return 0;
4692   }
4693   {
4694     try {
4695       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (Dali::DaliException e) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4707       };
4708     } catch (...) {
4709       {
4710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4711       };
4712     }
4713   }
4714
4715   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4716   return jresult;
4717 }
4718
4719
4720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4721   void * jresult ;
4722   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4723   float arg2 ;
4724   Dali::Vector2 result;
4725
4726   arg1 = (Dali::Vector2 *)jarg1;
4727   arg2 = (float)jarg2;
4728   {
4729     try {
4730       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4731     } catch (std::out_of_range& e) {
4732       {
4733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4734       };
4735     } catch (std::exception& e) {
4736       {
4737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4738       };
4739     } catch (Dali::DaliException e) {
4740       {
4741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4742       };
4743     } catch (...) {
4744       {
4745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4746       };
4747     }
4748   }
4749
4750   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4751   return jresult;
4752 }
4753
4754
4755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4756   void * jresult ;
4757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4758   Dali::Vector2 *arg2 = 0 ;
4759   Dali::Vector2 *result = 0 ;
4760
4761   arg1 = (Dali::Vector2 *)jarg1;
4762   arg2 = (Dali::Vector2 *)jarg2;
4763   if (!arg2) {
4764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4765     return 0;
4766   }
4767   {
4768     try {
4769       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4770     } catch (std::out_of_range& e) {
4771       {
4772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4773       };
4774     } catch (std::exception& e) {
4775       {
4776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4777       };
4778     } catch (Dali::DaliException e) {
4779       {
4780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4781       };
4782     } catch (...) {
4783       {
4784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4785       };
4786     }
4787   }
4788
4789   jresult = (void *)result;
4790   return jresult;
4791 }
4792
4793
4794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4795   void * jresult ;
4796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4797   float arg2 ;
4798   Dali::Vector2 *result = 0 ;
4799
4800   arg1 = (Dali::Vector2 *)jarg1;
4801   arg2 = (float)jarg2;
4802   {
4803     try {
4804       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4805     } catch (std::out_of_range& e) {
4806       {
4807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4808       };
4809     } catch (std::exception& e) {
4810       {
4811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4812       };
4813     } catch (Dali::DaliException e) {
4814       {
4815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4816       };
4817     } catch (...) {
4818       {
4819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4820       };
4821     }
4822   }
4823
4824   jresult = (void *)result;
4825   return jresult;
4826 }
4827
4828
4829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4830   void * jresult ;
4831   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4832   Dali::Vector2 *arg2 = 0 ;
4833   Dali::Vector2 result;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   arg2 = (Dali::Vector2 *)jarg2;
4837   if (!arg2) {
4838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4839     return 0;
4840   }
4841   {
4842     try {
4843       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4844     } catch (std::out_of_range& e) {
4845       {
4846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4847       };
4848     } catch (std::exception& e) {
4849       {
4850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4851       };
4852     } catch (Dali::DaliException e) {
4853       {
4854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4855       };
4856     } catch (...) {
4857       {
4858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4859       };
4860     }
4861   }
4862
4863   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4864   return jresult;
4865 }
4866
4867
4868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4869   void * jresult ;
4870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4871   float arg2 ;
4872   Dali::Vector2 result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   arg2 = (float)jarg2;
4876   {
4877     try {
4878       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4879     } catch (std::out_of_range& e) {
4880       {
4881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4882       };
4883     } catch (std::exception& e) {
4884       {
4885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4886       };
4887     } catch (Dali::DaliException e) {
4888       {
4889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4890       };
4891     } catch (...) {
4892       {
4893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4894       };
4895     }
4896   }
4897
4898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4904   void * jresult ;
4905   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4906   Dali::Vector2 *arg2 = 0 ;
4907   Dali::Vector2 *result = 0 ;
4908
4909   arg1 = (Dali::Vector2 *)jarg1;
4910   arg2 = (Dali::Vector2 *)jarg2;
4911   if (!arg2) {
4912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4913     return 0;
4914   }
4915   {
4916     try {
4917       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4918     } catch (std::out_of_range& e) {
4919       {
4920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4921       };
4922     } catch (std::exception& e) {
4923       {
4924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4925       };
4926     } catch (Dali::DaliException e) {
4927       {
4928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4929       };
4930     } catch (...) {
4931       {
4932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4933       };
4934     }
4935   }
4936
4937   jresult = (void *)result;
4938   return jresult;
4939 }
4940
4941
4942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4943   void * jresult ;
4944   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4945   float arg2 ;
4946   Dali::Vector2 *result = 0 ;
4947
4948   arg1 = (Dali::Vector2 *)jarg1;
4949   arg2 = (float)jarg2;
4950   {
4951     try {
4952       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4953     } catch (std::out_of_range& e) {
4954       {
4955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4956       };
4957     } catch (std::exception& e) {
4958       {
4959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4960       };
4961     } catch (Dali::DaliException e) {
4962       {
4963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4964       };
4965     } catch (...) {
4966       {
4967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4968       };
4969     }
4970   }
4971
4972   jresult = (void *)result;
4973   return jresult;
4974 }
4975
4976
4977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4978   void * jresult ;
4979   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4980   Dali::Vector2 result;
4981
4982   arg1 = (Dali::Vector2 *)jarg1;
4983   {
4984     try {
4985       result = ((Dali::Vector2 const *)arg1)->operator -();
4986     } catch (std::out_of_range& e) {
4987       {
4988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4989       };
4990     } catch (std::exception& e) {
4991       {
4992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (Dali::DaliException e) {
4995       {
4996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004
5005   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5006   return jresult;
5007 }
5008
5009
5010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5011   unsigned int jresult ;
5012   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5013   Dali::Vector2 *arg2 = 0 ;
5014   bool result;
5015
5016   arg1 = (Dali::Vector2 *)jarg1;
5017   arg2 = (Dali::Vector2 *)jarg2;
5018   if (!arg2) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5020     return 0;
5021   }
5022   {
5023     try {
5024       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5025     } catch (std::out_of_range& e) {
5026       {
5027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5028       };
5029     } catch (std::exception& e) {
5030       {
5031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (Dali::DaliException e) {
5034       {
5035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5036       };
5037     } catch (...) {
5038       {
5039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5040       };
5041     }
5042   }
5043
5044   jresult = result;
5045   return jresult;
5046 }
5047
5048
5049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5050   unsigned int jresult ;
5051   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5052   Dali::Vector2 *arg2 = 0 ;
5053   bool result;
5054
5055   arg1 = (Dali::Vector2 *)jarg1;
5056   arg2 = (Dali::Vector2 *)jarg2;
5057   if (!arg2) {
5058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5059     return 0;
5060   }
5061   {
5062     try {
5063       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5064     } catch (std::out_of_range& e) {
5065       {
5066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5067       };
5068     } catch (std::exception& e) {
5069       {
5070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (Dali::DaliException e) {
5073       {
5074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5075       };
5076     } catch (...) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5079       };
5080     }
5081   }
5082
5083   jresult = result;
5084   return jresult;
5085 }
5086
5087
5088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5089   float jresult ;
5090   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5091   unsigned int arg2 ;
5092   float *result = 0 ;
5093
5094   arg1 = (Dali::Vector2 *)jarg1;
5095   arg2 = (unsigned int)jarg2;
5096   {
5097     try {
5098       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5099     } catch (std::out_of_range& e) {
5100       {
5101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5102       };
5103     } catch (std::exception& e) {
5104       {
5105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5106       };
5107     } catch (Dali::DaliException e) {
5108       {
5109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5110       };
5111     } catch (...) {
5112       {
5113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5114       };
5115     }
5116   }
5117
5118   jresult = *result;
5119   return jresult;
5120 }
5121
5122
5123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5124   float jresult ;
5125   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5126   float result;
5127
5128   arg1 = (Dali::Vector2 *)jarg1;
5129   {
5130     try {
5131       result = (float)((Dali::Vector2 const *)arg1)->Length();
5132     } catch (std::out_of_range& e) {
5133       {
5134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5135       };
5136     } catch (std::exception& e) {
5137       {
5138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5139       };
5140     } catch (Dali::DaliException e) {
5141       {
5142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5143       };
5144     } catch (...) {
5145       {
5146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5147       };
5148     }
5149   }
5150
5151   jresult = result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5157   float jresult ;
5158   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5159   float result;
5160
5161   arg1 = (Dali::Vector2 *)jarg1;
5162   {
5163     try {
5164       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5165     } catch (std::out_of_range& e) {
5166       {
5167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5168       };
5169     } catch (std::exception& e) {
5170       {
5171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5172       };
5173     } catch (Dali::DaliException e) {
5174       {
5175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5176       };
5177     } catch (...) {
5178       {
5179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5180       };
5181     }
5182   }
5183
5184   jresult = result;
5185   return jresult;
5186 }
5187
5188
5189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5190   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5191
5192   arg1 = (Dali::Vector2 *)jarg1;
5193   {
5194     try {
5195       (arg1)->Normalize();
5196     } catch (std::out_of_range& e) {
5197       {
5198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5199       };
5200     } catch (std::exception& e) {
5201       {
5202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5203       };
5204     } catch (Dali::DaliException e) {
5205       {
5206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5207       };
5208     } catch (...) {
5209       {
5210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5211       };
5212     }
5213   }
5214
5215 }
5216
5217
5218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5219   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5220   Dali::Vector2 *arg2 = 0 ;
5221   Dali::Vector2 *arg3 = 0 ;
5222
5223   arg1 = (Dali::Vector2 *)jarg1;
5224   arg2 = (Dali::Vector2 *)jarg2;
5225   if (!arg2) {
5226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5227     return ;
5228   }
5229   arg3 = (Dali::Vector2 *)jarg3;
5230   if (!arg3) {
5231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5232     return ;
5233   }
5234   {
5235     try {
5236       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5237     } catch (std::out_of_range& e) {
5238       {
5239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5240       };
5241     } catch (std::exception& e) {
5242       {
5243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5244       };
5245     } catch (Dali::DaliException e) {
5246       {
5247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5248       };
5249     } catch (...) {
5250       {
5251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5252       };
5253     }
5254   }
5255
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5260   void * jresult ;
5261   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5262   float *result = 0 ;
5263
5264   arg1 = (Dali::Vector2 *)jarg1;
5265   {
5266     try {
5267       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5268     } catch (std::out_of_range& e) {
5269       {
5270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5271       };
5272     } catch (std::exception& e) {
5273       {
5274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5275       };
5276     } catch (Dali::DaliException e) {
5277       {
5278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5279       };
5280     } catch (...) {
5281       {
5282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5283       };
5284     }
5285   }
5286
5287   jresult = (void *)result;
5288   return jresult;
5289 }
5290
5291
5292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5293   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5294   float arg2 ;
5295
5296   arg1 = (Dali::Vector2 *)jarg1;
5297   arg2 = (float)jarg2;
5298   if (arg1) (arg1)->x = arg2;
5299 }
5300
5301
5302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5303   float jresult ;
5304   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5305   float result;
5306
5307   arg1 = (Dali::Vector2 *)jarg1;
5308   result = (float) ((arg1)->x);
5309   jresult = result;
5310   return jresult;
5311 }
5312
5313
5314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5316   float arg2 ;
5317
5318   arg1 = (Dali::Vector2 *)jarg1;
5319   arg2 = (float)jarg2;
5320   if (arg1) (arg1)->width = arg2;
5321 }
5322
5323
5324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5325   float jresult ;
5326   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5327   float result;
5328
5329   arg1 = (Dali::Vector2 *)jarg1;
5330   result = (float) ((arg1)->width);
5331   jresult = result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float arg2 ;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   arg2 = (float)jarg2;
5342   if (arg1) (arg1)->y = arg2;
5343 }
5344
5345
5346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5347   float jresult ;
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float result;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   result = (float) ((arg1)->y);
5353   jresult = result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float arg2 ;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   arg2 = (float)jarg2;
5364   if (arg1) (arg1)->height = arg2;
5365 }
5366
5367
5368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5369   float jresult ;
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float result;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   result = (float) ((arg1)->height);
5375   jresult = result;
5376   return jresult;
5377 }
5378
5379
5380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   {
5385     try {
5386       delete arg1;
5387     } catch (std::out_of_range& e) {
5388       {
5389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5390       };
5391     } catch (std::exception& e) {
5392       {
5393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5394       };
5395     } catch (Dali::DaliException e) {
5396       {
5397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5398       };
5399     } catch (...) {
5400       {
5401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5402       };
5403     }
5404   }
5405
5406 }
5407
5408
5409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5410   void * jresult ;
5411   Dali::Vector2 *arg1 = 0 ;
5412   Dali::Vector2 *arg2 = 0 ;
5413   Dali::Vector2 result;
5414
5415   arg1 = (Dali::Vector2 *)jarg1;
5416   if (!arg1) {
5417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5418     return 0;
5419   }
5420   arg2 = (Dali::Vector2 *)jarg2;
5421   if (!arg2) {
5422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5423     return 0;
5424   }
5425   {
5426     try {
5427       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5428     } catch (std::out_of_range& e) {
5429       {
5430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5431       };
5432     } catch (std::exception& e) {
5433       {
5434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5435       };
5436     } catch (Dali::DaliException e) {
5437       {
5438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5439       };
5440     } catch (...) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5443       };
5444     }
5445   }
5446
5447   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5448   return jresult;
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector2 *arg1 = 0 ;
5455   Dali::Vector2 *arg2 = 0 ;
5456   Dali::Vector2 result;
5457
5458   arg1 = (Dali::Vector2 *)jarg1;
5459   if (!arg1) {
5460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5461     return 0;
5462   }
5463   arg2 = (Dali::Vector2 *)jarg2;
5464   if (!arg2) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   {
5469     try {
5470       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5471     } catch (std::out_of_range& e) {
5472       {
5473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (std::exception& e) {
5476       {
5477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (Dali::DaliException e) {
5480       {
5481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5482       };
5483     } catch (...) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5486       };
5487     }
5488   }
5489
5490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5491   return jresult;
5492 }
5493
5494
5495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5496   void * jresult ;
5497   Dali::Vector2 *arg1 = 0 ;
5498   float *arg2 = 0 ;
5499   float *arg3 = 0 ;
5500   float temp2 ;
5501   float temp3 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   temp2 = (float)jarg2;
5510   arg2 = &temp2;
5511   temp3 = (float)jarg3;
5512   arg3 = &temp3;
5513   {
5514     try {
5515       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (Dali::DaliException e) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5527       };
5528     } catch (...) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5531       };
5532     }
5533   }
5534
5535   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5536   return jresult;
5537 }
5538
5539
5540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5541   void * jresult ;
5542   Dali::Vector3 *result = 0 ;
5543
5544   {
5545     try {
5546       result = (Dali::Vector3 *)new Dali::Vector3();
5547     } catch (std::out_of_range& e) {
5548       {
5549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5550       };
5551     } catch (std::exception& e) {
5552       {
5553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (Dali::DaliException e) {
5556       {
5557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5558       };
5559     } catch (...) {
5560       {
5561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5562       };
5563     }
5564   }
5565
5566   jresult = (void *)result;
5567   return jresult;
5568 }
5569
5570
5571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5572   void * jresult ;
5573   float arg1 ;
5574   float arg2 ;
5575   float arg3 ;
5576   Dali::Vector3 *result = 0 ;
5577
5578   arg1 = (float)jarg1;
5579   arg2 = (float)jarg2;
5580   arg3 = (float)jarg3;
5581   {
5582     try {
5583       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5584     } catch (std::out_of_range& e) {
5585       {
5586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (std::exception& e) {
5589       {
5590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5591       };
5592     } catch (Dali::DaliException e) {
5593       {
5594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5595       };
5596     } catch (...) {
5597       {
5598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5599       };
5600     }
5601   }
5602
5603   jresult = (void *)result;
5604   return jresult;
5605 }
5606
5607
5608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5609   void * jresult ;
5610   float *arg1 = (float *) 0 ;
5611   Dali::Vector3 *result = 0 ;
5612
5613   arg1 = jarg1;
5614   {
5615     try {
5616       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5617     } catch (std::out_of_range& e) {
5618       {
5619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5620       };
5621     } catch (std::exception& e) {
5622       {
5623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5624       };
5625     } catch (Dali::DaliException e) {
5626       {
5627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5628       };
5629     } catch (...) {
5630       {
5631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5632       };
5633     }
5634   }
5635
5636   jresult = (void *)result;
5637
5638
5639   return jresult;
5640 }
5641
5642
5643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5644   void * jresult ;
5645   Dali::Vector2 *arg1 = 0 ;
5646   Dali::Vector3 *result = 0 ;
5647
5648   arg1 = (Dali::Vector2 *)jarg1;
5649   if (!arg1) {
5650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5651     return 0;
5652   }
5653   {
5654     try {
5655       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5656     } catch (std::out_of_range& e) {
5657       {
5658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5659       };
5660     } catch (std::exception& e) {
5661       {
5662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (Dali::DaliException e) {
5665       {
5666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5667       };
5668     } catch (...) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5671       };
5672     }
5673   }
5674
5675   jresult = (void *)result;
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5681   void * jresult ;
5682   Dali::Vector4 *arg1 = 0 ;
5683   Dali::Vector3 *result = 0 ;
5684
5685   arg1 = (Dali::Vector4 *)jarg1;
5686   if (!arg1) {
5687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5688     return 0;
5689   }
5690   {
5691     try {
5692       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5693     } catch (std::out_of_range& e) {
5694       {
5695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5696       };
5697     } catch (std::exception& e) {
5698       {
5699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (Dali::DaliException e) {
5702       {
5703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5704       };
5705     } catch (...) {
5706       {
5707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5708       };
5709     }
5710   }
5711
5712   jresult = (void *)result;
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5718   void * jresult ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5728   void * jresult ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5732   jresult = (void *)result;
5733   return jresult;
5734 }
5735
5736
5737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5738   void * jresult ;
5739   Dali::Vector3 *result = 0 ;
5740
5741   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5742   jresult = (void *)result;
5743   return jresult;
5744 }
5745
5746
5747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5748   void * jresult ;
5749   Dali::Vector3 *result = 0 ;
5750
5751   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5752   jresult = (void *)result;
5753   return jresult;
5754 }
5755
5756
5757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5758   void * jresult ;
5759   Dali::Vector3 *result = 0 ;
5760
5761   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5762   jresult = (void *)result;
5763   return jresult;
5764 }
5765
5766
5767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5768   void * jresult ;
5769   Dali::Vector3 *result = 0 ;
5770
5771   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5772   jresult = (void *)result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5778   void * jresult ;
5779   Dali::Vector3 *result = 0 ;
5780
5781   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5782   jresult = (void *)result;
5783   return jresult;
5784 }
5785
5786
5787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5788   void * jresult ;
5789   Dali::Vector3 *result = 0 ;
5790
5791   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5792   jresult = (void *)result;
5793   return jresult;
5794 }
5795
5796
5797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5798   void * jresult ;
5799   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5800   float *arg2 = (float *) 0 ;
5801   Dali::Vector3 *result = 0 ;
5802
5803   arg1 = (Dali::Vector3 *)jarg1;
5804   arg2 = jarg2;
5805   {
5806     try {
5807       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5808     } catch (std::out_of_range& e) {
5809       {
5810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5811       };
5812     } catch (std::exception& e) {
5813       {
5814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5815       };
5816     } catch (Dali::DaliException e) {
5817       {
5818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5819       };
5820     } catch (...) {
5821       {
5822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5823       };
5824     }
5825   }
5826
5827   jresult = (void *)result;
5828
5829
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5835   void * jresult ;
5836   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5837   Dali::Vector2 *arg2 = 0 ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   arg1 = (Dali::Vector3 *)jarg1;
5841   arg2 = (Dali::Vector2 *)jarg2;
5842   if (!arg2) {
5843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5844     return 0;
5845   }
5846   {
5847     try {
5848       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5849     } catch (std::out_of_range& e) {
5850       {
5851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5852       };
5853     } catch (std::exception& e) {
5854       {
5855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (Dali::DaliException e) {
5858       {
5859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5860       };
5861     } catch (...) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5864       };
5865     }
5866   }
5867
5868   jresult = (void *)result;
5869   return jresult;
5870 }
5871
5872
5873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5874   void * jresult ;
5875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5876   Dali::Vector4 *arg2 = 0 ;
5877   Dali::Vector3 *result = 0 ;
5878
5879   arg1 = (Dali::Vector3 *)jarg1;
5880   arg2 = (Dali::Vector4 *)jarg2;
5881   if (!arg2) {
5882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5883     return 0;
5884   }
5885   {
5886     try {
5887       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5888     } catch (std::out_of_range& e) {
5889       {
5890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (std::exception& e) {
5893       {
5894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (Dali::DaliException e) {
5897       {
5898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5899       };
5900     } catch (...) {
5901       {
5902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5903       };
5904     }
5905   }
5906
5907   jresult = (void *)result;
5908   return jresult;
5909 }
5910
5911
5912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5913   void * jresult ;
5914   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5915   Dali::Vector3 *arg2 = 0 ;
5916   Dali::Vector3 result;
5917
5918   arg1 = (Dali::Vector3 *)jarg1;
5919   arg2 = (Dali::Vector3 *)jarg2;
5920   if (!arg2) {
5921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5922     return 0;
5923   }
5924   {
5925     try {
5926       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5927     } catch (std::out_of_range& e) {
5928       {
5929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5930       };
5931     } catch (std::exception& e) {
5932       {
5933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5934       };
5935     } catch (Dali::DaliException e) {
5936       {
5937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5938       };
5939     } catch (...) {
5940       {
5941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5942       };
5943     }
5944   }
5945
5946   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5947   return jresult;
5948 }
5949
5950
5951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5952   void * jresult ;
5953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5954   Dali::Vector3 *arg2 = 0 ;
5955   Dali::Vector3 *result = 0 ;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   arg2 = (Dali::Vector3 *)jarg2;
5959   if (!arg2) {
5960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5961     return 0;
5962   }
5963   {
5964     try {
5965       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5966     } catch (std::out_of_range& e) {
5967       {
5968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (std::exception& e) {
5971       {
5972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (Dali::DaliException e) {
5975       {
5976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5977       };
5978     } catch (...) {
5979       {
5980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5981       };
5982     }
5983   }
5984
5985   jresult = (void *)result;
5986   return jresult;
5987 }
5988
5989
5990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5991   void * jresult ;
5992   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5993   Dali::Vector3 *arg2 = 0 ;
5994   Dali::Vector3 result;
5995
5996   arg1 = (Dali::Vector3 *)jarg1;
5997   arg2 = (Dali::Vector3 *)jarg2;
5998   if (!arg2) {
5999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6000     return 0;
6001   }
6002   {
6003     try {
6004       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6005     } catch (std::out_of_range& e) {
6006       {
6007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6008       };
6009     } catch (std::exception& e) {
6010       {
6011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6012       };
6013     } catch (Dali::DaliException e) {
6014       {
6015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6016       };
6017     } catch (...) {
6018       {
6019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6020       };
6021     }
6022   }
6023
6024   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6025   return jresult;
6026 }
6027
6028
6029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6030   void * jresult ;
6031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6032   Dali::Vector3 *arg2 = 0 ;
6033   Dali::Vector3 *result = 0 ;
6034
6035   arg1 = (Dali::Vector3 *)jarg1;
6036   arg2 = (Dali::Vector3 *)jarg2;
6037   if (!arg2) {
6038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6039     return 0;
6040   }
6041   {
6042     try {
6043       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6044     } catch (std::out_of_range& e) {
6045       {
6046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6047       };
6048     } catch (std::exception& e) {
6049       {
6050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (Dali::DaliException e) {
6053       {
6054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6055       };
6056     } catch (...) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6059       };
6060     }
6061   }
6062
6063   jresult = (void *)result;
6064   return jresult;
6065 }
6066
6067
6068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6069   void * jresult ;
6070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6071   Dali::Vector3 *arg2 = 0 ;
6072   Dali::Vector3 result;
6073
6074   arg1 = (Dali::Vector3 *)jarg1;
6075   arg2 = (Dali::Vector3 *)jarg2;
6076   if (!arg2) {
6077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6078     return 0;
6079   }
6080   {
6081     try {
6082       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6083     } catch (std::out_of_range& e) {
6084       {
6085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6086       };
6087     } catch (std::exception& e) {
6088       {
6089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6090       };
6091     } catch (Dali::DaliException e) {
6092       {
6093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6094       };
6095     } catch (...) {
6096       {
6097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6098       };
6099     }
6100   }
6101
6102   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6103   return jresult;
6104 }
6105
6106
6107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6108   void * jresult ;
6109   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6110   float arg2 ;
6111   Dali::Vector3 result;
6112
6113   arg1 = (Dali::Vector3 *)jarg1;
6114   arg2 = (float)jarg2;
6115   {
6116     try {
6117       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6118     } catch (std::out_of_range& e) {
6119       {
6120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6121       };
6122     } catch (std::exception& e) {
6123       {
6124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6125       };
6126     } catch (Dali::DaliException e) {
6127       {
6128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6129       };
6130     } catch (...) {
6131       {
6132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6133       };
6134     }
6135   }
6136
6137   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6138   return jresult;
6139 }
6140
6141
6142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6143   void * jresult ;
6144   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6145   Dali::Vector3 *arg2 = 0 ;
6146   Dali::Vector3 *result = 0 ;
6147
6148   arg1 = (Dali::Vector3 *)jarg1;
6149   arg2 = (Dali::Vector3 *)jarg2;
6150   if (!arg2) {
6151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6152     return 0;
6153   }
6154   {
6155     try {
6156       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6157     } catch (std::out_of_range& e) {
6158       {
6159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6160       };
6161     } catch (std::exception& e) {
6162       {
6163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6164       };
6165     } catch (Dali::DaliException e) {
6166       {
6167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6168       };
6169     } catch (...) {
6170       {
6171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6172       };
6173     }
6174   }
6175
6176   jresult = (void *)result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6182   void * jresult ;
6183   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6184   float arg2 ;
6185   Dali::Vector3 *result = 0 ;
6186
6187   arg1 = (Dali::Vector3 *)jarg1;
6188   arg2 = (float)jarg2;
6189   {
6190     try {
6191       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6192     } catch (std::out_of_range& e) {
6193       {
6194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6195       };
6196     } catch (std::exception& e) {
6197       {
6198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (Dali::DaliException e) {
6201       {
6202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6203       };
6204     } catch (...) {
6205       {
6206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6207       };
6208     }
6209   }
6210
6211   jresult = (void *)result;
6212   return jresult;
6213 }
6214
6215
6216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6217   void * jresult ;
6218   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6219   Dali::Quaternion *arg2 = 0 ;
6220   Dali::Vector3 *result = 0 ;
6221
6222   arg1 = (Dali::Vector3 *)jarg1;
6223   arg2 = (Dali::Quaternion *)jarg2;
6224   if (!arg2) {
6225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6226     return 0;
6227   }
6228   {
6229     try {
6230       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6231     } catch (std::out_of_range& e) {
6232       {
6233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6234       };
6235     } catch (std::exception& e) {
6236       {
6237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6238       };
6239     } catch (Dali::DaliException e) {
6240       {
6241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6242       };
6243     } catch (...) {
6244       {
6245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6246       };
6247     }
6248   }
6249
6250   jresult = (void *)result;
6251   return jresult;
6252 }
6253
6254
6255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6256   void * jresult ;
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   Dali::Vector3 *arg2 = 0 ;
6259   Dali::Vector3 result;
6260
6261   arg1 = (Dali::Vector3 *)jarg1;
6262   arg2 = (Dali::Vector3 *)jarg2;
6263   if (!arg2) {
6264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6265     return 0;
6266   }
6267   {
6268     try {
6269       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6270     } catch (std::out_of_range& e) {
6271       {
6272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6273       };
6274     } catch (std::exception& e) {
6275       {
6276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6277       };
6278     } catch (Dali::DaliException e) {
6279       {
6280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6281       };
6282     } catch (...) {
6283       {
6284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6285       };
6286     }
6287   }
6288
6289   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6290   return jresult;
6291 }
6292
6293
6294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6295   void * jresult ;
6296   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6297   float arg2 ;
6298   Dali::Vector3 result;
6299
6300   arg1 = (Dali::Vector3 *)jarg1;
6301   arg2 = (float)jarg2;
6302   {
6303     try {
6304       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6305     } catch (std::out_of_range& e) {
6306       {
6307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6308       };
6309     } catch (std::exception& e) {
6310       {
6311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6312       };
6313     } catch (Dali::DaliException e) {
6314       {
6315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6316       };
6317     } catch (...) {
6318       {
6319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6320       };
6321     }
6322   }
6323
6324   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6330   void * jresult ;
6331   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6332   Dali::Vector3 *arg2 = 0 ;
6333   Dali::Vector3 *result = 0 ;
6334
6335   arg1 = (Dali::Vector3 *)jarg1;
6336   arg2 = (Dali::Vector3 *)jarg2;
6337   if (!arg2) {
6338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6339     return 0;
6340   }
6341   {
6342     try {
6343       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6344     } catch (std::out_of_range& e) {
6345       {
6346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6347       };
6348     } catch (std::exception& e) {
6349       {
6350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6351       };
6352     } catch (Dali::DaliException e) {
6353       {
6354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6355       };
6356     } catch (...) {
6357       {
6358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6359       };
6360     }
6361   }
6362
6363   jresult = (void *)result;
6364   return jresult;
6365 }
6366
6367
6368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6369   void * jresult ;
6370   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6371   float arg2 ;
6372   Dali::Vector3 *result = 0 ;
6373
6374   arg1 = (Dali::Vector3 *)jarg1;
6375   arg2 = (float)jarg2;
6376   {
6377     try {
6378       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6379     } catch (std::out_of_range& e) {
6380       {
6381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6382       };
6383     } catch (std::exception& e) {
6384       {
6385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6386       };
6387     } catch (Dali::DaliException e) {
6388       {
6389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6390       };
6391     } catch (...) {
6392       {
6393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6394       };
6395     }
6396   }
6397
6398   jresult = (void *)result;
6399   return jresult;
6400 }
6401
6402
6403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6404   void * jresult ;
6405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6406   Dali::Vector3 result;
6407
6408   arg1 = (Dali::Vector3 *)jarg1;
6409   {
6410     try {
6411       result = ((Dali::Vector3 const *)arg1)->operator -();
6412     } catch (std::out_of_range& e) {
6413       {
6414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6415       };
6416     } catch (std::exception& e) {
6417       {
6418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6419       };
6420     } catch (Dali::DaliException e) {
6421       {
6422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6423       };
6424     } catch (...) {
6425       {
6426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6427       };
6428     }
6429   }
6430
6431   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6437   unsigned int jresult ;
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439   Dali::Vector3 *arg2 = 0 ;
6440   bool result;
6441
6442   arg1 = (Dali::Vector3 *)jarg1;
6443   arg2 = (Dali::Vector3 *)jarg2;
6444   if (!arg2) {
6445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6446     return 0;
6447   }
6448   {
6449     try {
6450       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6451     } catch (std::out_of_range& e) {
6452       {
6453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6454       };
6455     } catch (std::exception& e) {
6456       {
6457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6458       };
6459     } catch (Dali::DaliException e) {
6460       {
6461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6462       };
6463     } catch (...) {
6464       {
6465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6466       };
6467     }
6468   }
6469
6470   jresult = result;
6471   return jresult;
6472 }
6473
6474
6475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6476   unsigned int jresult ;
6477   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6478   Dali::Vector3 *arg2 = 0 ;
6479   bool result;
6480
6481   arg1 = (Dali::Vector3 *)jarg1;
6482   arg2 = (Dali::Vector3 *)jarg2;
6483   if (!arg2) {
6484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6485     return 0;
6486   }
6487   {
6488     try {
6489       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6490     } catch (std::out_of_range& e) {
6491       {
6492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6493       };
6494     } catch (std::exception& e) {
6495       {
6496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (Dali::DaliException e) {
6499       {
6500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6501       };
6502     } catch (...) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6505       };
6506     }
6507   }
6508
6509   jresult = result;
6510   return jresult;
6511 }
6512
6513
6514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6515   float jresult ;
6516   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6517   unsigned int arg2 ;
6518   float *result = 0 ;
6519
6520   arg1 = (Dali::Vector3 *)jarg1;
6521   arg2 = (unsigned int)jarg2;
6522   {
6523     try {
6524       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6525     } catch (std::out_of_range& e) {
6526       {
6527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6528       };
6529     } catch (std::exception& e) {
6530       {
6531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6532       };
6533     } catch (Dali::DaliException e) {
6534       {
6535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6536       };
6537     } catch (...) {
6538       {
6539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6540       };
6541     }
6542   }
6543
6544   jresult = *result;
6545   return jresult;
6546 }
6547
6548
6549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6550   float jresult ;
6551   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6552   Dali::Vector3 *arg2 = 0 ;
6553   float result;
6554
6555   arg1 = (Dali::Vector3 *)jarg1;
6556   arg2 = (Dali::Vector3 *)jarg2;
6557   if (!arg2) {
6558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6559     return 0;
6560   }
6561   {
6562     try {
6563       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6564     } catch (std::out_of_range& e) {
6565       {
6566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (std::exception& e) {
6569       {
6570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (Dali::DaliException e) {
6573       {
6574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6575       };
6576     } catch (...) {
6577       {
6578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6579       };
6580     }
6581   }
6582
6583   jresult = result;
6584   return jresult;
6585 }
6586
6587
6588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6589   void * jresult ;
6590   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6591   Dali::Vector3 *arg2 = 0 ;
6592   Dali::Vector3 result;
6593
6594   arg1 = (Dali::Vector3 *)jarg1;
6595   arg2 = (Dali::Vector3 *)jarg2;
6596   if (!arg2) {
6597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6598     return 0;
6599   }
6600   {
6601     try {
6602       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6603     } catch (std::out_of_range& e) {
6604       {
6605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6606       };
6607     } catch (std::exception& e) {
6608       {
6609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6610       };
6611     } catch (Dali::DaliException e) {
6612       {
6613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6614       };
6615     } catch (...) {
6616       {
6617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6618       };
6619     }
6620   }
6621
6622   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6623   return jresult;
6624 }
6625
6626
6627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6628   float jresult ;
6629   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6630   float result;
6631
6632   arg1 = (Dali::Vector3 *)jarg1;
6633   {
6634     try {
6635       result = (float)((Dali::Vector3 const *)arg1)->Length();
6636     } catch (std::out_of_range& e) {
6637       {
6638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6639       };
6640     } catch (std::exception& e) {
6641       {
6642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6643       };
6644     } catch (Dali::DaliException e) {
6645       {
6646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6647       };
6648     } catch (...) {
6649       {
6650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6651       };
6652     }
6653   }
6654
6655   jresult = result;
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6661   float jresult ;
6662   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6663   float result;
6664
6665   arg1 = (Dali::Vector3 *)jarg1;
6666   {
6667     try {
6668       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6669     } catch (std::out_of_range& e) {
6670       {
6671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6672       };
6673     } catch (std::exception& e) {
6674       {
6675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6676       };
6677     } catch (Dali::DaliException e) {
6678       {
6679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6680       };
6681     } catch (...) {
6682       {
6683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6684       };
6685     }
6686   }
6687
6688   jresult = result;
6689   return jresult;
6690 }
6691
6692
6693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6694   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6695
6696   arg1 = (Dali::Vector3 *)jarg1;
6697   {
6698     try {
6699       (arg1)->Normalize();
6700     } catch (std::out_of_range& e) {
6701       {
6702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6703       };
6704     } catch (std::exception& e) {
6705       {
6706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6707       };
6708     } catch (Dali::DaliException e) {
6709       {
6710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6711       };
6712     } catch (...) {
6713       {
6714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6715       };
6716     }
6717   }
6718
6719 }
6720
6721
6722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6723   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6724   Dali::Vector3 *arg2 = 0 ;
6725   Dali::Vector3 *arg3 = 0 ;
6726
6727   arg1 = (Dali::Vector3 *)jarg1;
6728   arg2 = (Dali::Vector3 *)jarg2;
6729   if (!arg2) {
6730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6731     return ;
6732   }
6733   arg3 = (Dali::Vector3 *)jarg3;
6734   if (!arg3) {
6735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6736     return ;
6737   }
6738   {
6739     try {
6740       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6741     } catch (std::out_of_range& e) {
6742       {
6743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6744       };
6745     } catch (std::exception& e) {
6746       {
6747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6748       };
6749     } catch (Dali::DaliException e) {
6750       {
6751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6756       };
6757     }
6758   }
6759
6760 }
6761
6762
6763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6764   void * jresult ;
6765   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6766   float *result = 0 ;
6767
6768   arg1 = (Dali::Vector3 *)jarg1;
6769   {
6770     try {
6771       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6772     } catch (std::out_of_range& e) {
6773       {
6774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6775       };
6776     } catch (std::exception& e) {
6777       {
6778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6779       };
6780     } catch (Dali::DaliException e) {
6781       {
6782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6783       };
6784     } catch (...) {
6785       {
6786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6787       };
6788     }
6789   }
6790
6791   jresult = (void *)result;
6792   return jresult;
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6797   void * jresult ;
6798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6799   Dali::Vector2 *result = 0 ;
6800
6801   arg1 = (Dali::Vector3 *)jarg1;
6802   {
6803     try {
6804       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6805     } catch (std::out_of_range& e) {
6806       {
6807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6808       };
6809     } catch (std::exception& e) {
6810       {
6811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6812       };
6813     } catch (Dali::DaliException e) {
6814       {
6815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6816       };
6817     } catch (...) {
6818       {
6819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6820       };
6821     }
6822   }
6823
6824   jresult = (void *)result;
6825   return jresult;
6826 }
6827
6828
6829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6830   void * jresult ;
6831   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6832   Dali::Vector2 *result = 0 ;
6833
6834   arg1 = (Dali::Vector3 *)jarg1;
6835   {
6836     try {
6837       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6838     } catch (std::out_of_range& e) {
6839       {
6840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6841       };
6842     } catch (std::exception& e) {
6843       {
6844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (Dali::DaliException e) {
6847       {
6848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6849       };
6850     } catch (...) {
6851       {
6852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6853       };
6854     }
6855   }
6856
6857   jresult = (void *)result;
6858   return jresult;
6859 }
6860
6861
6862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6863   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6864   float arg2 ;
6865
6866   arg1 = (Dali::Vector3 *)jarg1;
6867   arg2 = (float)jarg2;
6868   if (arg1) (arg1)->x = arg2;
6869 }
6870
6871
6872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6873   float jresult ;
6874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6875   float result;
6876
6877   arg1 = (Dali::Vector3 *)jarg1;
6878   result = (float) ((arg1)->x);
6879   jresult = result;
6880   return jresult;
6881 }
6882
6883
6884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6886   float arg2 ;
6887
6888   arg1 = (Dali::Vector3 *)jarg1;
6889   arg2 = (float)jarg2;
6890   if (arg1) (arg1)->width = arg2;
6891 }
6892
6893
6894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6895   float jresult ;
6896   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6897   float result;
6898
6899   arg1 = (Dali::Vector3 *)jarg1;
6900   result = (float) ((arg1)->width);
6901   jresult = result;
6902   return jresult;
6903 }
6904
6905
6906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float arg2 ;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   arg2 = (float)jarg2;
6912   if (arg1) (arg1)->r = arg2;
6913 }
6914
6915
6916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6917   float jresult ;
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float result;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   result = (float) ((arg1)->r);
6923   jresult = result;
6924   return jresult;
6925 }
6926
6927
6928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float arg2 ;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   arg2 = (float)jarg2;
6934   if (arg1) (arg1)->y = arg2;
6935 }
6936
6937
6938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6939   float jresult ;
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float result;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   result = (float) ((arg1)->y);
6945   jresult = result;
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float arg2 ;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   arg2 = (float)jarg2;
6956   if (arg1) (arg1)->height = arg2;
6957 }
6958
6959
6960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6961   float jresult ;
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float result;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   result = (float) ((arg1)->height);
6967   jresult = result;
6968   return jresult;
6969 }
6970
6971
6972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float arg2 ;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   arg2 = (float)jarg2;
6978   if (arg1) (arg1)->g = arg2;
6979 }
6980
6981
6982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6983   float jresult ;
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float result;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   result = (float) ((arg1)->g);
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float arg2 ;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   arg2 = (float)jarg2;
7000   if (arg1) (arg1)->z = arg2;
7001 }
7002
7003
7004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7005   float jresult ;
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float result;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   result = (float) ((arg1)->z);
7011   jresult = result;
7012   return jresult;
7013 }
7014
7015
7016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float arg2 ;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   arg2 = (float)jarg2;
7022   if (arg1) (arg1)->depth = arg2;
7023 }
7024
7025
7026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7027   float jresult ;
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float result;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   result = (float) ((arg1)->depth);
7033   jresult = result;
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float arg2 ;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   arg2 = (float)jarg2;
7044   if (arg1) (arg1)->b = arg2;
7045 }
7046
7047
7048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7049   float jresult ;
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float result;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   result = (float) ((arg1)->b);
7055   jresult = result;
7056   return jresult;
7057 }
7058
7059
7060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   {
7065     try {
7066       delete arg1;
7067     } catch (std::out_of_range& e) {
7068       {
7069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7070       };
7071     } catch (std::exception& e) {
7072       {
7073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7074       };
7075     } catch (Dali::DaliException e) {
7076       {
7077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7078       };
7079     } catch (...) {
7080       {
7081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7082       };
7083     }
7084   }
7085
7086 }
7087
7088
7089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7090   void * jresult ;
7091   Dali::Vector3 *arg1 = 0 ;
7092   Dali::Vector3 *arg2 = 0 ;
7093   Dali::Vector3 result;
7094
7095   arg1 = (Dali::Vector3 *)jarg1;
7096   if (!arg1) {
7097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7098     return 0;
7099   }
7100   arg2 = (Dali::Vector3 *)jarg2;
7101   if (!arg2) {
7102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7103     return 0;
7104   }
7105   {
7106     try {
7107       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7108     } catch (std::out_of_range& e) {
7109       {
7110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7111       };
7112     } catch (std::exception& e) {
7113       {
7114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7115       };
7116     } catch (Dali::DaliException e) {
7117       {
7118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7119       };
7120     } catch (...) {
7121       {
7122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7123       };
7124     }
7125   }
7126
7127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7128   return jresult;
7129 }
7130
7131
7132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7133   void * jresult ;
7134   Dali::Vector3 *arg1 = 0 ;
7135   Dali::Vector3 *arg2 = 0 ;
7136   Dali::Vector3 result;
7137
7138   arg1 = (Dali::Vector3 *)jarg1;
7139   if (!arg1) {
7140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7141     return 0;
7142   }
7143   arg2 = (Dali::Vector3 *)jarg2;
7144   if (!arg2) {
7145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7146     return 0;
7147   }
7148   {
7149     try {
7150       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7151     } catch (std::out_of_range& e) {
7152       {
7153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7154       };
7155     } catch (std::exception& e) {
7156       {
7157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (Dali::DaliException e) {
7160       {
7161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7162       };
7163     } catch (...) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7166       };
7167     }
7168   }
7169
7170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7171   return jresult;
7172 }
7173
7174
7175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7176   void * jresult ;
7177   Dali::Vector3 *arg1 = 0 ;
7178   float *arg2 = 0 ;
7179   float *arg3 = 0 ;
7180   float temp2 ;
7181   float temp3 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   temp2 = (float)jarg2;
7190   arg2 = &temp2;
7191   temp3 = (float)jarg3;
7192   arg3 = &temp3;
7193   {
7194     try {
7195       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7196     } catch (std::out_of_range& e) {
7197       {
7198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7199       };
7200     } catch (std::exception& e) {
7201       {
7202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (Dali::DaliException e) {
7205       {
7206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7207       };
7208     } catch (...) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7211       };
7212     }
7213   }
7214
7215   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7221   void * jresult ;
7222   Dali::Vector4 *result = 0 ;
7223
7224   {
7225     try {
7226       result = (Dali::Vector4 *)new Dali::Vector4();
7227     } catch (std::out_of_range& e) {
7228       {
7229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7230       };
7231     } catch (std::exception& e) {
7232       {
7233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7234       };
7235     } catch (Dali::DaliException e) {
7236       {
7237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7238       };
7239     } catch (...) {
7240       {
7241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7242       };
7243     }
7244   }
7245
7246   jresult = (void *)result;
7247   return jresult;
7248 }
7249
7250
7251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7252   void * jresult ;
7253   float arg1 ;
7254   float arg2 ;
7255   float arg3 ;
7256   float arg4 ;
7257   Dali::Vector4 *result = 0 ;
7258
7259   arg1 = (float)jarg1;
7260   arg2 = (float)jarg2;
7261   arg3 = (float)jarg3;
7262   arg4 = (float)jarg4;
7263   {
7264     try {
7265       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7266     } catch (std::out_of_range& e) {
7267       {
7268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (std::exception& e) {
7271       {
7272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (Dali::DaliException e) {
7275       {
7276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7277       };
7278     } catch (...) {
7279       {
7280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7281       };
7282     }
7283   }
7284
7285   jresult = (void *)result;
7286   return jresult;
7287 }
7288
7289
7290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7291   void * jresult ;
7292   float *arg1 = (float *) 0 ;
7293   Dali::Vector4 *result = 0 ;
7294
7295   arg1 = jarg1;
7296   {
7297     try {
7298       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7299     } catch (std::out_of_range& e) {
7300       {
7301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7302       };
7303     } catch (std::exception& e) {
7304       {
7305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7306       };
7307     } catch (Dali::DaliException e) {
7308       {
7309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7310       };
7311     } catch (...) {
7312       {
7313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7314       };
7315     }
7316   }
7317
7318   jresult = (void *)result;
7319
7320
7321   return jresult;
7322 }
7323
7324
7325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7326   void * jresult ;
7327   Dali::Vector2 *arg1 = 0 ;
7328   Dali::Vector4 *result = 0 ;
7329
7330   arg1 = (Dali::Vector2 *)jarg1;
7331   if (!arg1) {
7332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7333     return 0;
7334   }
7335   {
7336     try {
7337       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7338     } catch (std::out_of_range& e) {
7339       {
7340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7341       };
7342     } catch (std::exception& e) {
7343       {
7344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7345       };
7346     } catch (Dali::DaliException e) {
7347       {
7348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7349       };
7350     } catch (...) {
7351       {
7352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7353       };
7354     }
7355   }
7356
7357   jresult = (void *)result;
7358   return jresult;
7359 }
7360
7361
7362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7363   void * jresult ;
7364   Dali::Vector3 *arg1 = 0 ;
7365   Dali::Vector4 *result = 0 ;
7366
7367   arg1 = (Dali::Vector3 *)jarg1;
7368   if (!arg1) {
7369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7370     return 0;
7371   }
7372   {
7373     try {
7374       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7375     } catch (std::out_of_range& e) {
7376       {
7377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7378       };
7379     } catch (std::exception& e) {
7380       {
7381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (Dali::DaliException e) {
7384       {
7385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7386       };
7387     } catch (...) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7390       };
7391     }
7392   }
7393
7394   jresult = (void *)result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7400   void * jresult ;
7401   Dali::Vector4 *result = 0 ;
7402
7403   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7410   void * jresult ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7414   jresult = (void *)result;
7415   return jresult;
7416 }
7417
7418
7419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7420   void * jresult ;
7421   Dali::Vector4 *result = 0 ;
7422
7423   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7424   jresult = (void *)result;
7425   return jresult;
7426 }
7427
7428
7429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7430   void * jresult ;
7431   Dali::Vector4 *result = 0 ;
7432
7433   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7434   jresult = (void *)result;
7435   return jresult;
7436 }
7437
7438
7439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7440   void * jresult ;
7441   Dali::Vector4 *result = 0 ;
7442
7443   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7444   jresult = (void *)result;
7445   return jresult;
7446 }
7447
7448
7449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7450   void * jresult ;
7451   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7452   float *arg2 = (float *) 0 ;
7453   Dali::Vector4 *result = 0 ;
7454
7455   arg1 = (Dali::Vector4 *)jarg1;
7456   arg2 = jarg2;
7457   {
7458     try {
7459       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7460     } catch (std::out_of_range& e) {
7461       {
7462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7463       };
7464     } catch (std::exception& e) {
7465       {
7466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7467       };
7468     } catch (Dali::DaliException e) {
7469       {
7470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7471       };
7472     } catch (...) {
7473       {
7474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7475       };
7476     }
7477   }
7478
7479   jresult = (void *)result;
7480
7481
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7487   void * jresult ;
7488   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7489   Dali::Vector2 *arg2 = 0 ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   arg1 = (Dali::Vector4 *)jarg1;
7493   arg2 = (Dali::Vector2 *)jarg2;
7494   if (!arg2) {
7495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7496     return 0;
7497   }
7498   {
7499     try {
7500       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7501     } catch (std::out_of_range& e) {
7502       {
7503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7504       };
7505     } catch (std::exception& e) {
7506       {
7507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7508       };
7509     } catch (Dali::DaliException e) {
7510       {
7511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7512       };
7513     } catch (...) {
7514       {
7515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7516       };
7517     }
7518   }
7519
7520   jresult = (void *)result;
7521   return jresult;
7522 }
7523
7524
7525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7526   void * jresult ;
7527   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7528   Dali::Vector3 *arg2 = 0 ;
7529   Dali::Vector4 *result = 0 ;
7530
7531   arg1 = (Dali::Vector4 *)jarg1;
7532   arg2 = (Dali::Vector3 *)jarg2;
7533   if (!arg2) {
7534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7535     return 0;
7536   }
7537   {
7538     try {
7539       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7540     } catch (std::out_of_range& e) {
7541       {
7542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7543       };
7544     } catch (std::exception& e) {
7545       {
7546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (Dali::DaliException e) {
7549       {
7550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7551       };
7552     } catch (...) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7555       };
7556     }
7557   }
7558
7559   jresult = (void *)result;
7560   return jresult;
7561 }
7562
7563
7564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7565   void * jresult ;
7566   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7567   Dali::Vector4 *arg2 = 0 ;
7568   Dali::Vector4 result;
7569
7570   arg1 = (Dali::Vector4 *)jarg1;
7571   arg2 = (Dali::Vector4 *)jarg2;
7572   if (!arg2) {
7573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7574     return 0;
7575   }
7576   {
7577     try {
7578       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7579     } catch (std::out_of_range& e) {
7580       {
7581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7582       };
7583     } catch (std::exception& e) {
7584       {
7585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7586       };
7587     } catch (Dali::DaliException e) {
7588       {
7589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7590       };
7591     } catch (...) {
7592       {
7593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7594       };
7595     }
7596   }
7597
7598   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7599   return jresult;
7600 }
7601
7602
7603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7604   void * jresult ;
7605   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7606   Dali::Vector4 *arg2 = 0 ;
7607   Dali::Vector4 *result = 0 ;
7608
7609   arg1 = (Dali::Vector4 *)jarg1;
7610   arg2 = (Dali::Vector4 *)jarg2;
7611   if (!arg2) {
7612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7613     return 0;
7614   }
7615   {
7616     try {
7617       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7618     } catch (std::out_of_range& e) {
7619       {
7620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7621       };
7622     } catch (std::exception& e) {
7623       {
7624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7625       };
7626     } catch (Dali::DaliException e) {
7627       {
7628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7629       };
7630     } catch (...) {
7631       {
7632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7633       };
7634     }
7635   }
7636
7637   jresult = (void *)result;
7638   return jresult;
7639 }
7640
7641
7642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7643   void * jresult ;
7644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7645   Dali::Vector4 *arg2 = 0 ;
7646   Dali::Vector4 result;
7647
7648   arg1 = (Dali::Vector4 *)jarg1;
7649   arg2 = (Dali::Vector4 *)jarg2;
7650   if (!arg2) {
7651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7652     return 0;
7653   }
7654   {
7655     try {
7656       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7657     } catch (std::out_of_range& e) {
7658       {
7659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7660       };
7661     } catch (std::exception& e) {
7662       {
7663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7664       };
7665     } catch (Dali::DaliException e) {
7666       {
7667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7668       };
7669     } catch (...) {
7670       {
7671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7672       };
7673     }
7674   }
7675
7676   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7682   void * jresult ;
7683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7684   Dali::Vector4 *arg2 = 0 ;
7685   Dali::Vector4 *result = 0 ;
7686
7687   arg1 = (Dali::Vector4 *)jarg1;
7688   arg2 = (Dali::Vector4 *)jarg2;
7689   if (!arg2) {
7690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7691     return 0;
7692   }
7693   {
7694     try {
7695       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7696     } catch (std::out_of_range& e) {
7697       {
7698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7699       };
7700     } catch (std::exception& e) {
7701       {
7702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7703       };
7704     } catch (Dali::DaliException e) {
7705       {
7706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7707       };
7708     } catch (...) {
7709       {
7710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7711       };
7712     }
7713   }
7714
7715   jresult = (void *)result;
7716   return jresult;
7717 }
7718
7719
7720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7721   void * jresult ;
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   Dali::Vector4 *arg2 = 0 ;
7724   Dali::Vector4 result;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   arg2 = (Dali::Vector4 *)jarg2;
7728   if (!arg2) {
7729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7730     return 0;
7731   }
7732   {
7733     try {
7734       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7735     } catch (std::out_of_range& e) {
7736       {
7737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7738       };
7739     } catch (std::exception& e) {
7740       {
7741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7742       };
7743     } catch (Dali::DaliException e) {
7744       {
7745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7746       };
7747     } catch (...) {
7748       {
7749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7750       };
7751     }
7752   }
7753
7754   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7755   return jresult;
7756 }
7757
7758
7759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7760   void * jresult ;
7761   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7762   float arg2 ;
7763   Dali::Vector4 result;
7764
7765   arg1 = (Dali::Vector4 *)jarg1;
7766   arg2 = (float)jarg2;
7767   {
7768     try {
7769       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7770     } catch (std::out_of_range& e) {
7771       {
7772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7773       };
7774     } catch (std::exception& e) {
7775       {
7776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7777       };
7778     } catch (Dali::DaliException e) {
7779       {
7780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7781       };
7782     } catch (...) {
7783       {
7784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7785       };
7786     }
7787   }
7788
7789   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7790   return jresult;
7791 }
7792
7793
7794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7795   void * jresult ;
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   Dali::Vector4 *arg2 = 0 ;
7798   Dali::Vector4 *result = 0 ;
7799
7800   arg1 = (Dali::Vector4 *)jarg1;
7801   arg2 = (Dali::Vector4 *)jarg2;
7802   if (!arg2) {
7803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7804     return 0;
7805   }
7806   {
7807     try {
7808       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7809     } catch (std::out_of_range& e) {
7810       {
7811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7812       };
7813     } catch (std::exception& e) {
7814       {
7815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7816       };
7817     } catch (Dali::DaliException e) {
7818       {
7819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7820       };
7821     } catch (...) {
7822       {
7823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7824       };
7825     }
7826   }
7827
7828   jresult = (void *)result;
7829   return jresult;
7830 }
7831
7832
7833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7834   void * jresult ;
7835   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7836   float arg2 ;
7837   Dali::Vector4 *result = 0 ;
7838
7839   arg1 = (Dali::Vector4 *)jarg1;
7840   arg2 = (float)jarg2;
7841   {
7842     try {
7843       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7844     } catch (std::out_of_range& e) {
7845       {
7846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7847       };
7848     } catch (std::exception& e) {
7849       {
7850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7851       };
7852     } catch (Dali::DaliException e) {
7853       {
7854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7855       };
7856     } catch (...) {
7857       {
7858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7859       };
7860     }
7861   }
7862
7863   jresult = (void *)result;
7864   return jresult;
7865 }
7866
7867
7868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7869   void * jresult ;
7870   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7871   Dali::Vector4 *arg2 = 0 ;
7872   Dali::Vector4 result;
7873
7874   arg1 = (Dali::Vector4 *)jarg1;
7875   arg2 = (Dali::Vector4 *)jarg2;
7876   if (!arg2) {
7877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7878     return 0;
7879   }
7880   {
7881     try {
7882       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7883     } catch (std::out_of_range& e) {
7884       {
7885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7886       };
7887     } catch (std::exception& e) {
7888       {
7889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (Dali::DaliException e) {
7892       {
7893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7894       };
7895     } catch (...) {
7896       {
7897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7898       };
7899     }
7900   }
7901
7902   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7903   return jresult;
7904 }
7905
7906
7907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7908   void * jresult ;
7909   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7910   float arg2 ;
7911   Dali::Vector4 result;
7912
7913   arg1 = (Dali::Vector4 *)jarg1;
7914   arg2 = (float)jarg2;
7915   {
7916     try {
7917       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7918     } catch (std::out_of_range& e) {
7919       {
7920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7921       };
7922     } catch (std::exception& e) {
7923       {
7924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7925       };
7926     } catch (Dali::DaliException e) {
7927       {
7928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7929       };
7930     } catch (...) {
7931       {
7932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7933       };
7934     }
7935   }
7936
7937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7938   return jresult;
7939 }
7940
7941
7942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7943   void * jresult ;
7944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7945   Dali::Vector4 *arg2 = 0 ;
7946   Dali::Vector4 *result = 0 ;
7947
7948   arg1 = (Dali::Vector4 *)jarg1;
7949   arg2 = (Dali::Vector4 *)jarg2;
7950   if (!arg2) {
7951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7952     return 0;
7953   }
7954   {
7955     try {
7956       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7957     } catch (std::out_of_range& e) {
7958       {
7959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7960       };
7961     } catch (std::exception& e) {
7962       {
7963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7964       };
7965     } catch (Dali::DaliException e) {
7966       {
7967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7968       };
7969     } catch (...) {
7970       {
7971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7972       };
7973     }
7974   }
7975
7976   jresult = (void *)result;
7977   return jresult;
7978 }
7979
7980
7981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7982   void * jresult ;
7983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7984   float arg2 ;
7985   Dali::Vector4 *result = 0 ;
7986
7987   arg1 = (Dali::Vector4 *)jarg1;
7988   arg2 = (float)jarg2;
7989   {
7990     try {
7991       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7992     } catch (std::out_of_range& e) {
7993       {
7994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7995       };
7996     } catch (std::exception& e) {
7997       {
7998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7999       };
8000     } catch (Dali::DaliException e) {
8001       {
8002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8003       };
8004     } catch (...) {
8005       {
8006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8007       };
8008     }
8009   }
8010
8011   jresult = (void *)result;
8012   return jresult;
8013 }
8014
8015
8016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8017   void * jresult ;
8018   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8019   Dali::Vector4 result;
8020
8021   arg1 = (Dali::Vector4 *)jarg1;
8022   {
8023     try {
8024       result = ((Dali::Vector4 const *)arg1)->operator -();
8025     } catch (std::out_of_range& e) {
8026       {
8027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8028       };
8029     } catch (std::exception& e) {
8030       {
8031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8032       };
8033     } catch (Dali::DaliException e) {
8034       {
8035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8036       };
8037     } catch (...) {
8038       {
8039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8040       };
8041     }
8042   }
8043
8044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8045   return jresult;
8046 }
8047
8048
8049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8050   unsigned int jresult ;
8051   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8052   Dali::Vector4 *arg2 = 0 ;
8053   bool result;
8054
8055   arg1 = (Dali::Vector4 *)jarg1;
8056   arg2 = (Dali::Vector4 *)jarg2;
8057   if (!arg2) {
8058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8059     return 0;
8060   }
8061   {
8062     try {
8063       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8064     } catch (std::out_of_range& e) {
8065       {
8066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (std::exception& e) {
8069       {
8070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (Dali::DaliException e) {
8073       {
8074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8075       };
8076     } catch (...) {
8077       {
8078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8079       };
8080     }
8081   }
8082
8083   jresult = result;
8084   return jresult;
8085 }
8086
8087
8088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8089   unsigned int jresult ;
8090   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8091   Dali::Vector4 *arg2 = 0 ;
8092   bool result;
8093
8094   arg1 = (Dali::Vector4 *)jarg1;
8095   arg2 = (Dali::Vector4 *)jarg2;
8096   if (!arg2) {
8097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8098     return 0;
8099   }
8100   {
8101     try {
8102       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8103     } catch (std::out_of_range& e) {
8104       {
8105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8106       };
8107     } catch (std::exception& e) {
8108       {
8109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8110       };
8111     } catch (Dali::DaliException e) {
8112       {
8113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8114       };
8115     } catch (...) {
8116       {
8117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8118       };
8119     }
8120   }
8121
8122   jresult = result;
8123   return jresult;
8124 }
8125
8126
8127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8128   float jresult ;
8129   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8130   unsigned int arg2 ;
8131   float *result = 0 ;
8132
8133   arg1 = (Dali::Vector4 *)jarg1;
8134   arg2 = (unsigned int)jarg2;
8135   {
8136     try {
8137       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8138     } catch (std::out_of_range& e) {
8139       {
8140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8141       };
8142     } catch (std::exception& e) {
8143       {
8144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8145       };
8146     } catch (Dali::DaliException e) {
8147       {
8148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8149       };
8150     } catch (...) {
8151       {
8152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8153       };
8154     }
8155   }
8156
8157   jresult = *result;
8158   return jresult;
8159 }
8160
8161
8162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8163   float jresult ;
8164   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8165   Dali::Vector3 *arg2 = 0 ;
8166   float result;
8167
8168   arg1 = (Dali::Vector4 *)jarg1;
8169   arg2 = (Dali::Vector3 *)jarg2;
8170   if (!arg2) {
8171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8172     return 0;
8173   }
8174   {
8175     try {
8176       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8177     } catch (std::out_of_range& e) {
8178       {
8179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8180       };
8181     } catch (std::exception& e) {
8182       {
8183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (Dali::DaliException e) {
8186       {
8187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8188       };
8189     } catch (...) {
8190       {
8191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8192       };
8193     }
8194   }
8195
8196   jresult = result;
8197   return jresult;
8198 }
8199
8200
8201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8202   float jresult ;
8203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8204   Dali::Vector4 *arg2 = 0 ;
8205   float result;
8206
8207   arg1 = (Dali::Vector4 *)jarg1;
8208   arg2 = (Dali::Vector4 *)jarg2;
8209   if (!arg2) {
8210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8211     return 0;
8212   }
8213   {
8214     try {
8215       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8216     } catch (std::out_of_range& e) {
8217       {
8218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8219       };
8220     } catch (std::exception& e) {
8221       {
8222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8223       };
8224     } catch (Dali::DaliException e) {
8225       {
8226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8227       };
8228     } catch (...) {
8229       {
8230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8231       };
8232     }
8233   }
8234
8235   jresult = result;
8236   return jresult;
8237 }
8238
8239
8240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8241   float jresult ;
8242   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8243   Dali::Vector4 *arg2 = 0 ;
8244   float result;
8245
8246   arg1 = (Dali::Vector4 *)jarg1;
8247   arg2 = (Dali::Vector4 *)jarg2;
8248   if (!arg2) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8250     return 0;
8251   }
8252   {
8253     try {
8254       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8255     } catch (std::out_of_range& e) {
8256       {
8257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8258       };
8259     } catch (std::exception& e) {
8260       {
8261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (Dali::DaliException e) {
8264       {
8265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8266       };
8267     } catch (...) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8270       };
8271     }
8272   }
8273
8274   jresult = result;
8275   return jresult;
8276 }
8277
8278
8279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8280   void * jresult ;
8281   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8282   Dali::Vector4 *arg2 = 0 ;
8283   Dali::Vector4 result;
8284
8285   arg1 = (Dali::Vector4 *)jarg1;
8286   arg2 = (Dali::Vector4 *)jarg2;
8287   if (!arg2) {
8288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8289     return 0;
8290   }
8291   {
8292     try {
8293       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8294     } catch (std::out_of_range& e) {
8295       {
8296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8297       };
8298     } catch (std::exception& e) {
8299       {
8300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (Dali::DaliException e) {
8303       {
8304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8305       };
8306     } catch (...) {
8307       {
8308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8309       };
8310     }
8311   }
8312
8313   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8314   return jresult;
8315 }
8316
8317
8318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8319   float jresult ;
8320   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8321   float result;
8322
8323   arg1 = (Dali::Vector4 *)jarg1;
8324   {
8325     try {
8326       result = (float)((Dali::Vector4 const *)arg1)->Length();
8327     } catch (std::out_of_range& e) {
8328       {
8329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8330       };
8331     } catch (std::exception& e) {
8332       {
8333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8334       };
8335     } catch (Dali::DaliException e) {
8336       {
8337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8338       };
8339     } catch (...) {
8340       {
8341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8342       };
8343     }
8344   }
8345
8346   jresult = result;
8347   return jresult;
8348 }
8349
8350
8351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8352   float jresult ;
8353   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8354   float result;
8355
8356   arg1 = (Dali::Vector4 *)jarg1;
8357   {
8358     try {
8359       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8360     } catch (std::out_of_range& e) {
8361       {
8362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8363       };
8364     } catch (std::exception& e) {
8365       {
8366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8367       };
8368     } catch (Dali::DaliException e) {
8369       {
8370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8371       };
8372     } catch (...) {
8373       {
8374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8375       };
8376     }
8377   }
8378
8379   jresult = result;
8380   return jresult;
8381 }
8382
8383
8384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8385   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8386
8387   arg1 = (Dali::Vector4 *)jarg1;
8388   {
8389     try {
8390       (arg1)->Normalize();
8391     } catch (std::out_of_range& e) {
8392       {
8393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8394       };
8395     } catch (std::exception& e) {
8396       {
8397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8398       };
8399     } catch (Dali::DaliException e) {
8400       {
8401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8402       };
8403     } catch (...) {
8404       {
8405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8406       };
8407     }
8408   }
8409
8410 }
8411
8412
8413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8414   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8415   Dali::Vector4 *arg2 = 0 ;
8416   Dali::Vector4 *arg3 = 0 ;
8417
8418   arg1 = (Dali::Vector4 *)jarg1;
8419   arg2 = (Dali::Vector4 *)jarg2;
8420   if (!arg2) {
8421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8422     return ;
8423   }
8424   arg3 = (Dali::Vector4 *)jarg3;
8425   if (!arg3) {
8426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8427     return ;
8428   }
8429   {
8430     try {
8431       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8432     } catch (std::out_of_range& e) {
8433       {
8434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8435       };
8436     } catch (std::exception& e) {
8437       {
8438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8439       };
8440     } catch (Dali::DaliException e) {
8441       {
8442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8447       };
8448     }
8449   }
8450
8451 }
8452
8453
8454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8455   void * jresult ;
8456   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8457   float *result = 0 ;
8458
8459   arg1 = (Dali::Vector4 *)jarg1;
8460   {
8461     try {
8462       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8463     } catch (std::out_of_range& e) {
8464       {
8465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8466       };
8467     } catch (std::exception& e) {
8468       {
8469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8470       };
8471     } catch (Dali::DaliException e) {
8472       {
8473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8474       };
8475     } catch (...) {
8476       {
8477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8478       };
8479     }
8480   }
8481
8482   jresult = (void *)result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8488   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8489   float arg2 ;
8490
8491   arg1 = (Dali::Vector4 *)jarg1;
8492   arg2 = (float)jarg2;
8493   if (arg1) (arg1)->x = arg2;
8494 }
8495
8496
8497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8498   float jresult ;
8499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8500   float result;
8501
8502   arg1 = (Dali::Vector4 *)jarg1;
8503   result = (float) ((arg1)->x);
8504   jresult = result;
8505   return jresult;
8506 }
8507
8508
8509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8511   float arg2 ;
8512
8513   arg1 = (Dali::Vector4 *)jarg1;
8514   arg2 = (float)jarg2;
8515   if (arg1) (arg1)->r = arg2;
8516 }
8517
8518
8519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8520   float jresult ;
8521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8522   float result;
8523
8524   arg1 = (Dali::Vector4 *)jarg1;
8525   result = (float) ((arg1)->r);
8526   jresult = result;
8527   return jresult;
8528 }
8529
8530
8531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float arg2 ;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   arg2 = (float)jarg2;
8537   if (arg1) (arg1)->s = arg2;
8538 }
8539
8540
8541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8542   float jresult ;
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float result;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   result = (float) ((arg1)->s);
8548   jresult = result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float arg2 ;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   arg2 = (float)jarg2;
8559   if (arg1) (arg1)->y = arg2;
8560 }
8561
8562
8563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8564   float jresult ;
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float result;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   result = (float) ((arg1)->y);
8570   jresult = result;
8571   return jresult;
8572 }
8573
8574
8575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float arg2 ;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   arg2 = (float)jarg2;
8581   if (arg1) (arg1)->g = arg2;
8582 }
8583
8584
8585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8586   float jresult ;
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float result;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   result = (float) ((arg1)->g);
8592   jresult = result;
8593   return jresult;
8594 }
8595
8596
8597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float arg2 ;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   arg2 = (float)jarg2;
8603   if (arg1) (arg1)->t = arg2;
8604 }
8605
8606
8607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8608   float jresult ;
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float result;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   result = (float) ((arg1)->t);
8614   jresult = result;
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float arg2 ;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   arg2 = (float)jarg2;
8625   if (arg1) (arg1)->z = arg2;
8626 }
8627
8628
8629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8630   float jresult ;
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float result;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   result = (float) ((arg1)->z);
8636   jresult = result;
8637   return jresult;
8638 }
8639
8640
8641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float arg2 ;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   arg2 = (float)jarg2;
8647   if (arg1) (arg1)->b = arg2;
8648 }
8649
8650
8651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8652   float jresult ;
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float result;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   result = (float) ((arg1)->b);
8658   jresult = result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float arg2 ;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   arg2 = (float)jarg2;
8669   if (arg1) (arg1)->p = arg2;
8670 }
8671
8672
8673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8674   float jresult ;
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float result;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   result = (float) ((arg1)->p);
8680   jresult = result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float arg2 ;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   arg2 = (float)jarg2;
8691   if (arg1) (arg1)->w = arg2;
8692 }
8693
8694
8695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8696   float jresult ;
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float result;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   result = (float) ((arg1)->w);
8702   jresult = result;
8703   return jresult;
8704 }
8705
8706
8707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float arg2 ;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   arg2 = (float)jarg2;
8713   if (arg1) (arg1)->a = arg2;
8714 }
8715
8716
8717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8718   float jresult ;
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float result;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   result = (float) ((arg1)->a);
8724   jresult = result;
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float arg2 ;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   arg2 = (float)jarg2;
8735   if (arg1) (arg1)->q = arg2;
8736 }
8737
8738
8739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8740   float jresult ;
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float result;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   result = (float) ((arg1)->q);
8746   jresult = result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   {
8756     try {
8757       delete arg1;
8758     } catch (std::out_of_range& e) {
8759       {
8760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8761       };
8762     } catch (std::exception& e) {
8763       {
8764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8765       };
8766     } catch (Dali::DaliException e) {
8767       {
8768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8769       };
8770     } catch (...) {
8771       {
8772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8773       };
8774     }
8775   }
8776
8777 }
8778
8779
8780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8781   void * jresult ;
8782   Dali::Vector4 *arg1 = 0 ;
8783   Dali::Vector4 *arg2 = 0 ;
8784   Dali::Vector4 result;
8785
8786   arg1 = (Dali::Vector4 *)jarg1;
8787   if (!arg1) {
8788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8789     return 0;
8790   }
8791   arg2 = (Dali::Vector4 *)jarg2;
8792   if (!arg2) {
8793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8794     return 0;
8795   }
8796   {
8797     try {
8798       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8799     } catch (std::out_of_range& e) {
8800       {
8801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8802       };
8803     } catch (std::exception& e) {
8804       {
8805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8806       };
8807     } catch (Dali::DaliException e) {
8808       {
8809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8810       };
8811     } catch (...) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8814       };
8815     }
8816   }
8817
8818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8819   return jresult;
8820 }
8821
8822
8823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8824   void * jresult ;
8825   Dali::Vector4 *arg1 = 0 ;
8826   Dali::Vector4 *arg2 = 0 ;
8827   Dali::Vector4 result;
8828
8829   arg1 = (Dali::Vector4 *)jarg1;
8830   if (!arg1) {
8831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8832     return 0;
8833   }
8834   arg2 = (Dali::Vector4 *)jarg2;
8835   if (!arg2) {
8836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8837     return 0;
8838   }
8839   {
8840     try {
8841       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8842     } catch (std::out_of_range& e) {
8843       {
8844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8845       };
8846     } catch (std::exception& e) {
8847       {
8848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (Dali::DaliException e) {
8851       {
8852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8853       };
8854     } catch (...) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8857       };
8858     }
8859   }
8860
8861   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8867   void * jresult ;
8868   Dali::Vector4 *arg1 = 0 ;
8869   float *arg2 = 0 ;
8870   float *arg3 = 0 ;
8871   float temp2 ;
8872   float temp3 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   temp2 = (float)jarg2;
8881   arg2 = &temp2;
8882   temp3 = (float)jarg3;
8883   arg3 = &temp3;
8884   {
8885     try {
8886       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8887     } catch (std::out_of_range& e) {
8888       {
8889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (std::exception& e) {
8892       {
8893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (Dali::DaliException e) {
8896       {
8897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8898       };
8899     } catch (...) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8902       };
8903     }
8904   }
8905
8906   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8912   void * jresult ;
8913   Dali::Uint16Pair *result = 0 ;
8914
8915   {
8916     try {
8917       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8918     } catch (std::out_of_range& e) {
8919       {
8920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (std::exception& e) {
8923       {
8924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8925       };
8926     } catch (Dali::DaliException e) {
8927       {
8928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8929       };
8930     } catch (...) {
8931       {
8932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8933       };
8934     }
8935   }
8936
8937   jresult = (void *)result;
8938   return jresult;
8939 }
8940
8941
8942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8943   void * jresult ;
8944   uint32_t arg1 ;
8945   uint32_t arg2 ;
8946   Dali::Uint16Pair *result = 0 ;
8947
8948   arg1 = (uint32_t)jarg1;
8949   arg2 = (uint32_t)jarg2;
8950   {
8951     try {
8952       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8953     } catch (std::out_of_range& e) {
8954       {
8955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8956       };
8957     } catch (std::exception& e) {
8958       {
8959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8960       };
8961     } catch (Dali::DaliException e) {
8962       {
8963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8964       };
8965     } catch (...) {
8966       {
8967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8968       };
8969     }
8970   }
8971
8972   jresult = (void *)result;
8973   return jresult;
8974 }
8975
8976
8977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8978   void * jresult ;
8979   Dali::Uint16Pair *arg1 = 0 ;
8980   Dali::Uint16Pair *result = 0 ;
8981
8982   arg1 = (Dali::Uint16Pair *)jarg1;
8983   if (!arg1) {
8984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8985     return 0;
8986   }
8987   {
8988     try {
8989       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8990     } catch (std::out_of_range& e) {
8991       {
8992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8993       };
8994     } catch (std::exception& e) {
8995       {
8996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8997       };
8998     } catch (Dali::DaliException e) {
8999       {
9000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9001       };
9002     } catch (...) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9005       };
9006     }
9007   }
9008
9009   jresult = (void *)result;
9010   return jresult;
9011 }
9012
9013
9014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9015   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9016   uint16_t arg2 ;
9017
9018   arg1 = (Dali::Uint16Pair *)jarg1;
9019   arg2 = (uint16_t)jarg2;
9020   {
9021     try {
9022       (arg1)->SetWidth(arg2);
9023     } catch (std::out_of_range& e) {
9024       {
9025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9026       };
9027     } catch (std::exception& e) {
9028       {
9029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9030       };
9031     } catch (Dali::DaliException e) {
9032       {
9033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9034       };
9035     } catch (...) {
9036       {
9037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9038       };
9039     }
9040   }
9041
9042 }
9043
9044
9045 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9046   unsigned short jresult ;
9047   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9048   uint16_t result;
9049
9050   arg1 = (Dali::Uint16Pair *)jarg1;
9051   {
9052     try {
9053       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9054     } catch (std::out_of_range& e) {
9055       {
9056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9057       };
9058     } catch (std::exception& e) {
9059       {
9060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9061       };
9062     } catch (Dali::DaliException e) {
9063       {
9064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9065       };
9066     } catch (...) {
9067       {
9068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9069       };
9070     }
9071   }
9072
9073   jresult = result;
9074   return jresult;
9075 }
9076
9077
9078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9079   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9080   uint16_t arg2 ;
9081
9082   arg1 = (Dali::Uint16Pair *)jarg1;
9083   arg2 = (uint16_t)jarg2;
9084   {
9085     try {
9086       (arg1)->SetHeight(arg2);
9087     } catch (std::out_of_range& e) {
9088       {
9089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9090       };
9091     } catch (std::exception& e) {
9092       {
9093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9094       };
9095     } catch (Dali::DaliException e) {
9096       {
9097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9098       };
9099     } catch (...) {
9100       {
9101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9102       };
9103     }
9104   }
9105
9106 }
9107
9108
9109 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9110   unsigned short jresult ;
9111   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9112   uint16_t result;
9113
9114   arg1 = (Dali::Uint16Pair *)jarg1;
9115   {
9116     try {
9117       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9118     } catch (std::out_of_range& e) {
9119       {
9120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9121       };
9122     } catch (std::exception& e) {
9123       {
9124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9125       };
9126     } catch (Dali::DaliException e) {
9127       {
9128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9129       };
9130     } catch (...) {
9131       {
9132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9133       };
9134     }
9135   }
9136
9137   jresult = result;
9138   return jresult;
9139 }
9140
9141
9142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9143   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9144   uint16_t arg2 ;
9145
9146   arg1 = (Dali::Uint16Pair *)jarg1;
9147   arg2 = (uint16_t)jarg2;
9148   {
9149     try {
9150       (arg1)->SetX(arg2);
9151     } catch (std::out_of_range& e) {
9152       {
9153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9154       };
9155     } catch (std::exception& e) {
9156       {
9157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9158       };
9159     } catch (Dali::DaliException e) {
9160       {
9161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9162       };
9163     } catch (...) {
9164       {
9165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9166       };
9167     }
9168   }
9169
9170 }
9171
9172
9173 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9174   unsigned short jresult ;
9175   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9176   uint16_t result;
9177
9178   arg1 = (Dali::Uint16Pair *)jarg1;
9179   {
9180     try {
9181       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9182     } catch (std::out_of_range& e) {
9183       {
9184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9185       };
9186     } catch (std::exception& e) {
9187       {
9188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9189       };
9190     } catch (Dali::DaliException e) {
9191       {
9192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9193       };
9194     } catch (...) {
9195       {
9196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9197       };
9198     }
9199   }
9200
9201   jresult = result;
9202   return jresult;
9203 }
9204
9205
9206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9207   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9208   uint16_t arg2 ;
9209
9210   arg1 = (Dali::Uint16Pair *)jarg1;
9211   arg2 = (uint16_t)jarg2;
9212   {
9213     try {
9214       (arg1)->SetY(arg2);
9215     } catch (std::out_of_range& e) {
9216       {
9217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9218       };
9219     } catch (std::exception& e) {
9220       {
9221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9222       };
9223     } catch (Dali::DaliException e) {
9224       {
9225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9230       };
9231     }
9232   }
9233
9234 }
9235
9236
9237 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9238   unsigned short jresult ;
9239   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9240   uint16_t result;
9241
9242   arg1 = (Dali::Uint16Pair *)jarg1;
9243   {
9244     try {
9245       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9246     } catch (std::out_of_range& e) {
9247       {
9248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (std::exception& e) {
9251       {
9252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9253       };
9254     } catch (Dali::DaliException e) {
9255       {
9256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9257       };
9258     } catch (...) {
9259       {
9260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9261       };
9262     }
9263   }
9264
9265   jresult = result;
9266   return jresult;
9267 }
9268
9269
9270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9271   void * jresult ;
9272   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9273   Dali::Uint16Pair *arg2 = 0 ;
9274   Dali::Uint16Pair *result = 0 ;
9275
9276   arg1 = (Dali::Uint16Pair *)jarg1;
9277   arg2 = (Dali::Uint16Pair *)jarg2;
9278   if (!arg2) {
9279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9280     return 0;
9281   }
9282   {
9283     try {
9284       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9285     } catch (std::out_of_range& e) {
9286       {
9287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9288       };
9289     } catch (std::exception& e) {
9290       {
9291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (Dali::DaliException e) {
9294       {
9295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9296       };
9297     } catch (...) {
9298       {
9299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9300       };
9301     }
9302   }
9303
9304   jresult = (void *)result;
9305   return jresult;
9306 }
9307
9308
9309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9310   unsigned int jresult ;
9311   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9312   Dali::Uint16Pair *arg2 = 0 ;
9313   bool result;
9314
9315   arg1 = (Dali::Uint16Pair *)jarg1;
9316   arg2 = (Dali::Uint16Pair *)jarg2;
9317   if (!arg2) {
9318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9319     return 0;
9320   }
9321   {
9322     try {
9323       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9324     } catch (std::out_of_range& e) {
9325       {
9326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9327       };
9328     } catch (std::exception& e) {
9329       {
9330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (Dali::DaliException e) {
9333       {
9334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9335       };
9336     } catch (...) {
9337       {
9338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9339       };
9340     }
9341   }
9342
9343   jresult = result;
9344   return jresult;
9345 }
9346
9347
9348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9349   unsigned int jresult ;
9350   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9351   Dali::Uint16Pair *arg2 = 0 ;
9352   bool result;
9353
9354   arg1 = (Dali::Uint16Pair *)jarg1;
9355   arg2 = (Dali::Uint16Pair *)jarg2;
9356   if (!arg2) {
9357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9358     return 0;
9359   }
9360   {
9361     try {
9362       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9363     } catch (std::out_of_range& e) {
9364       {
9365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9366       };
9367     } catch (std::exception& e) {
9368       {
9369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9370       };
9371     } catch (Dali::DaliException e) {
9372       {
9373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9374       };
9375     } catch (...) {
9376       {
9377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9378       };
9379     }
9380   }
9381
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9390   Dali::Uint16Pair *arg2 = 0 ;
9391   bool result;
9392
9393   arg1 = (Dali::Uint16Pair *)jarg1;
9394   arg2 = (Dali::Uint16Pair *)jarg2;
9395   if (!arg2) {
9396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9397     return 0;
9398   }
9399   {
9400     try {
9401       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9402     } catch (std::out_of_range& e) {
9403       {
9404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9405       };
9406     } catch (std::exception& e) {
9407       {
9408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9409       };
9410     } catch (Dali::DaliException e) {
9411       {
9412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9413       };
9414     } catch (...) {
9415       {
9416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9417       };
9418     }
9419   }
9420
9421   jresult = result;
9422   return jresult;
9423 }
9424
9425
9426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9427   unsigned int jresult ;
9428   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9429   Dali::Uint16Pair *arg2 = 0 ;
9430   bool result;
9431
9432   arg1 = (Dali::Uint16Pair *)jarg1;
9433   arg2 = (Dali::Uint16Pair *)jarg2;
9434   if (!arg2) {
9435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9436     return 0;
9437   }
9438   {
9439     try {
9440       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9441     } catch (std::out_of_range& e) {
9442       {
9443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9444       };
9445     } catch (std::exception& e) {
9446       {
9447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9448       };
9449     } catch (Dali::DaliException e) {
9450       {
9451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9452       };
9453     } catch (...) {
9454       {
9455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9456       };
9457     }
9458   }
9459
9460   jresult = result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9466   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9467
9468   arg1 = (Dali::Uint16Pair *)jarg1;
9469   {
9470     try {
9471       delete arg1;
9472     } catch (std::out_of_range& e) {
9473       {
9474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9475       };
9476     } catch (std::exception& e) {
9477       {
9478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9479       };
9480     } catch (Dali::DaliException e) {
9481       {
9482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9483       };
9484     } catch (...) {
9485       {
9486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9487       };
9488     }
9489   }
9490
9491 }
9492
9493
9494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9495   void * jresult ;
9496   Dali::Degree *result = 0 ;
9497
9498   {
9499     try {
9500       result = (Dali::Degree *)new Dali::Degree();
9501     } catch (std::out_of_range& e) {
9502       {
9503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9504       };
9505     } catch (std::exception& e) {
9506       {
9507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9508       };
9509     } catch (Dali::DaliException e) {
9510       {
9511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9512       };
9513     } catch (...) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9516       };
9517     }
9518   }
9519
9520   jresult = (void *)result;
9521   return jresult;
9522 }
9523
9524
9525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9526   void * jresult ;
9527   float arg1 ;
9528   Dali::Degree *result = 0 ;
9529
9530   arg1 = (float)jarg1;
9531   {
9532     try {
9533       result = (Dali::Degree *)new Dali::Degree(arg1);
9534     } catch (std::out_of_range& e) {
9535       {
9536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9537       };
9538     } catch (std::exception& e) {
9539       {
9540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9541       };
9542     } catch (Dali::DaliException e) {
9543       {
9544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9545       };
9546     } catch (...) {
9547       {
9548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9549       };
9550     }
9551   }
9552
9553   jresult = (void *)result;
9554   return jresult;
9555 }
9556
9557
9558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9559   void * jresult ;
9560   Dali::Radian arg1 ;
9561   Dali::Radian *argp1 ;
9562   Dali::Degree *result = 0 ;
9563
9564   argp1 = (Dali::Radian *)jarg1;
9565   if (!argp1) {
9566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9567     return 0;
9568   }
9569   arg1 = *argp1;
9570   {
9571     try {
9572       result = (Dali::Degree *)new Dali::Degree(arg1);
9573     } catch (std::out_of_range& e) {
9574       {
9575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9576       };
9577     } catch (std::exception& e) {
9578       {
9579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9580       };
9581     } catch (Dali::DaliException e) {
9582       {
9583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9584       };
9585     } catch (...) {
9586       {
9587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9588       };
9589     }
9590   }
9591
9592   jresult = (void *)result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9598   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9599   float arg2 ;
9600
9601   arg1 = (Dali::Degree *)jarg1;
9602   arg2 = (float)jarg2;
9603   if (arg1) (arg1)->degree = arg2;
9604 }
9605
9606
9607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9608   float jresult ;
9609   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9610   float result;
9611
9612   arg1 = (Dali::Degree *)jarg1;
9613   result = (float) ((arg1)->degree);
9614   jresult = result;
9615   return jresult;
9616 }
9617
9618
9619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9620   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9621
9622   arg1 = (Dali::Degree *)jarg1;
9623   {
9624     try {
9625       delete arg1;
9626     } catch (std::out_of_range& e) {
9627       {
9628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9629       };
9630     } catch (std::exception& e) {
9631       {
9632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9633       };
9634     } catch (Dali::DaliException e) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9637       };
9638     } catch (...) {
9639       {
9640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9641       };
9642     }
9643   }
9644
9645 }
9646
9647
9648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9649   void * jresult ;
9650   Dali::Radian *result = 0 ;
9651
9652   result = (Dali::Radian *)&Dali::ANGLE_360;
9653   jresult = (void *)result;
9654   return jresult;
9655 }
9656
9657
9658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9659   void * jresult ;
9660   Dali::Radian *result = 0 ;
9661
9662   result = (Dali::Radian *)&Dali::ANGLE_315;
9663   jresult = (void *)result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9669   void * jresult ;
9670   Dali::Radian *result = 0 ;
9671
9672   result = (Dali::Radian *)&Dali::ANGLE_270;
9673   jresult = (void *)result;
9674   return jresult;
9675 }
9676
9677
9678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9679   void * jresult ;
9680   Dali::Radian *result = 0 ;
9681
9682   result = (Dali::Radian *)&Dali::ANGLE_225;
9683   jresult = (void *)result;
9684   return jresult;
9685 }
9686
9687
9688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9689   void * jresult ;
9690   Dali::Radian *result = 0 ;
9691
9692   result = (Dali::Radian *)&Dali::ANGLE_180;
9693   jresult = (void *)result;
9694   return jresult;
9695 }
9696
9697
9698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9699   void * jresult ;
9700   Dali::Radian *result = 0 ;
9701
9702   result = (Dali::Radian *)&Dali::ANGLE_135;
9703   jresult = (void *)result;
9704   return jresult;
9705 }
9706
9707
9708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9709   void * jresult ;
9710   Dali::Radian *result = 0 ;
9711
9712   result = (Dali::Radian *)&Dali::ANGLE_120;
9713   jresult = (void *)result;
9714   return jresult;
9715 }
9716
9717
9718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9719   void * jresult ;
9720   Dali::Radian *result = 0 ;
9721
9722   result = (Dali::Radian *)&Dali::ANGLE_90;
9723   jresult = (void *)result;
9724   return jresult;
9725 }
9726
9727
9728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9729   void * jresult ;
9730   Dali::Radian *result = 0 ;
9731
9732   result = (Dali::Radian *)&Dali::ANGLE_60;
9733   jresult = (void *)result;
9734   return jresult;
9735 }
9736
9737
9738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9739   void * jresult ;
9740   Dali::Radian *result = 0 ;
9741
9742   result = (Dali::Radian *)&Dali::ANGLE_45;
9743   jresult = (void *)result;
9744   return jresult;
9745 }
9746
9747
9748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9749   void * jresult ;
9750   Dali::Radian *result = 0 ;
9751
9752   result = (Dali::Radian *)&Dali::ANGLE_30;
9753   jresult = (void *)result;
9754   return jresult;
9755 }
9756
9757
9758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9759   void * jresult ;
9760   Dali::Radian *result = 0 ;
9761
9762   result = (Dali::Radian *)&Dali::ANGLE_0;
9763   jresult = (void *)result;
9764   return jresult;
9765 }
9766
9767
9768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9769   unsigned int jresult ;
9770   Dali::Degree *arg1 = 0 ;
9771   Dali::Degree *arg2 = 0 ;
9772   bool result;
9773
9774   arg1 = (Dali::Degree *)jarg1;
9775   if (!arg1) {
9776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9777     return 0;
9778   }
9779   arg2 = (Dali::Degree *)jarg2;
9780   if (!arg2) {
9781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9782     return 0;
9783   }
9784   {
9785     try {
9786       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9787     } catch (std::out_of_range& e) {
9788       {
9789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9790       };
9791     } catch (std::exception& e) {
9792       {
9793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9794       };
9795     } catch (Dali::DaliException e) {
9796       {
9797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9798       };
9799     } catch (...) {
9800       {
9801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9802       };
9803     }
9804   }
9805
9806   jresult = result;
9807   return jresult;
9808 }
9809
9810
9811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9812   unsigned int jresult ;
9813   Dali::Degree *arg1 = 0 ;
9814   Dali::Degree *arg2 = 0 ;
9815   bool result;
9816
9817   arg1 = (Dali::Degree *)jarg1;
9818   if (!arg1) {
9819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9820     return 0;
9821   }
9822   arg2 = (Dali::Degree *)jarg2;
9823   if (!arg2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9825     return 0;
9826   }
9827   {
9828     try {
9829       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9830     } catch (std::out_of_range& e) {
9831       {
9832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9833       };
9834     } catch (std::exception& e) {
9835       {
9836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (Dali::DaliException e) {
9839       {
9840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9841       };
9842     } catch (...) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9845       };
9846     }
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9855   void * jresult ;
9856   Dali::Degree arg1 ;
9857   float arg2 ;
9858   float arg3 ;
9859   Dali::Degree *argp1 ;
9860   Dali::Degree result;
9861
9862   argp1 = (Dali::Degree *)jarg1;
9863   if (!argp1) {
9864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9865     return 0;
9866   }
9867   arg1 = *argp1;
9868   arg2 = (float)jarg2;
9869   arg3 = (float)jarg3;
9870   {
9871     try {
9872       result = Dali::Clamp(arg1,arg2,arg3);
9873     } catch (std::out_of_range& e) {
9874       {
9875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (std::exception& e) {
9878       {
9879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (Dali::DaliException e) {
9882       {
9883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9884       };
9885     } catch (...) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9888       };
9889     }
9890   }
9891
9892   jresult = new Dali::Degree((const Dali::Degree &)result);
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9898   void * jresult ;
9899   Dali::Radian *result = 0 ;
9900
9901   {
9902     try {
9903       result = (Dali::Radian *)new Dali::Radian();
9904     } catch (std::out_of_range& e) {
9905       {
9906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9907       };
9908     } catch (std::exception& e) {
9909       {
9910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9911       };
9912     } catch (Dali::DaliException e) {
9913       {
9914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9915       };
9916     } catch (...) {
9917       {
9918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9919       };
9920     }
9921   }
9922
9923   jresult = (void *)result;
9924   return jresult;
9925 }
9926
9927
9928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9929   void * jresult ;
9930   float arg1 ;
9931   Dali::Radian *result = 0 ;
9932
9933   arg1 = (float)jarg1;
9934   {
9935     try {
9936       result = (Dali::Radian *)new Dali::Radian(arg1);
9937     } catch (std::out_of_range& e) {
9938       {
9939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9940       };
9941     } catch (std::exception& e) {
9942       {
9943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9944       };
9945     } catch (Dali::DaliException e) {
9946       {
9947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9948       };
9949     } catch (...) {
9950       {
9951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9952       };
9953     }
9954   }
9955
9956   jresult = (void *)result;
9957   return jresult;
9958 }
9959
9960
9961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9962   void * jresult ;
9963   Dali::Degree arg1 ;
9964   Dali::Degree *argp1 ;
9965   Dali::Radian *result = 0 ;
9966
9967   argp1 = (Dali::Degree *)jarg1;
9968   if (!argp1) {
9969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9970     return 0;
9971   }
9972   arg1 = *argp1;
9973   {
9974     try {
9975       result = (Dali::Radian *)new Dali::Radian(arg1);
9976     } catch (std::out_of_range& e) {
9977       {
9978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (std::exception& e) {
9981       {
9982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9983       };
9984     } catch (Dali::DaliException e) {
9985       {
9986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9987       };
9988     } catch (...) {
9989       {
9990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9991       };
9992     }
9993   }
9994
9995   jresult = (void *)result;
9996   return jresult;
9997 }
9998
9999
10000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10001   void * jresult ;
10002   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10003   float arg2 ;
10004   Dali::Radian *result = 0 ;
10005
10006   arg1 = (Dali::Radian *)jarg1;
10007   arg2 = (float)jarg2;
10008   {
10009     try {
10010       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10011     } catch (std::out_of_range& e) {
10012       {
10013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10014       };
10015     } catch (std::exception& e) {
10016       {
10017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10018       };
10019     } catch (Dali::DaliException e) {
10020       {
10021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10022       };
10023     } catch (...) {
10024       {
10025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10026       };
10027     }
10028   }
10029
10030   jresult = (void *)result;
10031   return jresult;
10032 }
10033
10034
10035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10036   void * jresult ;
10037   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10038   Dali::Degree arg2 ;
10039   Dali::Degree *argp2 ;
10040   Dali::Radian *result = 0 ;
10041
10042   arg1 = (Dali::Radian *)jarg1;
10043   argp2 = (Dali::Degree *)jarg2;
10044   if (!argp2) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10046     return 0;
10047   }
10048   arg2 = *argp2;
10049   {
10050     try {
10051       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10052     } catch (std::out_of_range& e) {
10053       {
10054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10055       };
10056     } catch (std::exception& e) {
10057       {
10058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (Dali::DaliException e) {
10061       {
10062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10063       };
10064     } catch (...) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10067       };
10068     }
10069   }
10070
10071   jresult = (void *)result;
10072   return jresult;
10073 }
10074
10075
10076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10077   float jresult ;
10078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10079   float result;
10080
10081   arg1 = (Dali::Radian *)jarg1;
10082   {
10083     try {
10084       result = (float)((Dali::Radian const *)arg1)->operator float();
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (Dali::DaliException e) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10096       };
10097     } catch (...) {
10098       {
10099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10100       };
10101     }
10102   }
10103
10104   jresult = result;
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10110   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10111   float arg2 ;
10112
10113   arg1 = (Dali::Radian *)jarg1;
10114   arg2 = (float)jarg2;
10115   if (arg1) (arg1)->radian = arg2;
10116 }
10117
10118
10119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10120   float jresult ;
10121   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10122   float result;
10123
10124   arg1 = (Dali::Radian *)jarg1;
10125   result = (float) ((arg1)->radian);
10126   jresult = result;
10127   return jresult;
10128 }
10129
10130
10131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10133
10134   arg1 = (Dali::Radian *)jarg1;
10135   {
10136     try {
10137       delete arg1;
10138     } catch (std::out_of_range& e) {
10139       {
10140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10141       };
10142     } catch (std::exception& e) {
10143       {
10144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10145       };
10146     } catch (Dali::DaliException e) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10149       };
10150     } catch (...) {
10151       {
10152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10153       };
10154     }
10155   }
10156
10157 }
10158
10159
10160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10161   unsigned int jresult ;
10162   Dali::Radian arg1 ;
10163   Dali::Radian arg2 ;
10164   Dali::Radian *argp1 ;
10165   Dali::Radian *argp2 ;
10166   bool result;
10167
10168   argp1 = (Dali::Radian *)jarg1;
10169   if (!argp1) {
10170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10171     return 0;
10172   }
10173   arg1 = *argp1;
10174   argp2 = (Dali::Radian *)jarg2;
10175   if (!argp2) {
10176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10177     return 0;
10178   }
10179   arg2 = *argp2;
10180   {
10181     try {
10182       result = (bool)Dali::operator ==(arg1,arg2);
10183     } catch (std::out_of_range& e) {
10184       {
10185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10186       };
10187     } catch (std::exception& e) {
10188       {
10189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10190       };
10191     } catch (Dali::DaliException e) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10194       };
10195     } catch (...) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10198       };
10199     }
10200   }
10201
10202   jresult = result;
10203   return jresult;
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator !=(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Degree arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Degree *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Degree *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator ==(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator !=(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Degree arg1 ;
10351   Dali::Radian arg2 ;
10352   Dali::Degree *argp1 ;
10353   Dali::Radian *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Degree *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Radian *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator ==(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator !=(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Radian arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Radian *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Radian *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator >(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Degree arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Degree *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Degree *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Degree arg1 ;
10539   Dali::Radian arg2 ;
10540   Dali::Degree *argp1 ;
10541   Dali::Radian *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Degree *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Radian *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Radian arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Radian *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Radian *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator <(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Degree arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Degree *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Degree *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Degree arg1 ;
10680   Dali::Radian arg2 ;
10681   Dali::Degree *argp1 ;
10682   Dali::Radian *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Degree *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Radian *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10725   void * jresult ;
10726   Dali::Radian arg1 ;
10727   float arg2 ;
10728   Dali::Radian *argp1 ;
10729   Dali::Radian result;
10730
10731   argp1 = (Dali::Radian *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   arg2 = (float)jarg2;
10738   {
10739     try {
10740       result = Dali::operator *(arg1,arg2);
10741     } catch (std::out_of_range& e) {
10742       {
10743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10744       };
10745     } catch (std::exception& e) {
10746       {
10747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (Dali::DaliException e) {
10750       {
10751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10752       };
10753     } catch (...) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10756       };
10757     }
10758   }
10759
10760   jresult = new Dali::Radian((const Dali::Radian &)result);
10761   return jresult;
10762 }
10763
10764
10765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10766   void * jresult ;
10767   Dali::Radian arg1 ;
10768   Dali::Radian *argp1 ;
10769   Dali::Radian result;
10770
10771   argp1 = (Dali::Radian *)jarg1;
10772   if (!argp1) {
10773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10774     return 0;
10775   }
10776   arg1 = *argp1;
10777   {
10778     try {
10779       result = Dali::operator -(arg1);
10780     } catch (std::out_of_range& e) {
10781       {
10782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10783       };
10784     } catch (std::exception& e) {
10785       {
10786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10787       };
10788     } catch (Dali::DaliException e) {
10789       {
10790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10791       };
10792     } catch (...) {
10793       {
10794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10795       };
10796     }
10797   }
10798
10799   jresult = new Dali::Radian((const Dali::Radian &)result);
10800   return jresult;
10801 }
10802
10803
10804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10805   void * jresult ;
10806   Dali::Radian arg1 ;
10807   float arg2 ;
10808   float arg3 ;
10809   Dali::Radian *argp1 ;
10810   Dali::Radian result;
10811
10812   argp1 = (Dali::Radian *)jarg1;
10813   if (!argp1) {
10814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10815     return 0;
10816   }
10817   arg1 = *argp1;
10818   arg2 = (float)jarg2;
10819   arg3 = (float)jarg3;
10820   {
10821     try {
10822       result = Dali::Clamp(arg1,arg2,arg3);
10823     } catch (std::out_of_range& e) {
10824       {
10825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10826       };
10827     } catch (std::exception& e) {
10828       {
10829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (Dali::DaliException e) {
10832       {
10833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10834       };
10835     } catch (...) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10838       };
10839     }
10840   }
10841
10842   jresult = new Dali::Radian((const Dali::Radian &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10848   void * jresult ;
10849   Dali::Quaternion *result = 0 ;
10850
10851   {
10852     try {
10853       result = (Dali::Quaternion *)new Dali::Quaternion();
10854     } catch (std::out_of_range& e) {
10855       {
10856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10857       };
10858     } catch (std::exception& e) {
10859       {
10860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10861       };
10862     } catch (Dali::DaliException e) {
10863       {
10864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10865       };
10866     } catch (...) {
10867       {
10868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10869       };
10870     }
10871   }
10872
10873   jresult = (void *)result;
10874   return jresult;
10875 }
10876
10877
10878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10879   void * jresult ;
10880   Dali::Radian arg1 ;
10881   Dali::Vector3 *arg2 = 0 ;
10882   Dali::Radian *argp1 ;
10883   Dali::Quaternion *result = 0 ;
10884
10885   argp1 = (Dali::Radian *)jarg1;
10886   if (!argp1) {
10887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10888     return 0;
10889   }
10890   arg1 = *argp1;
10891   arg2 = (Dali::Vector3 *)jarg2;
10892   if (!arg2) {
10893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10894     return 0;
10895   }
10896   {
10897     try {
10898       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10899     } catch (std::out_of_range& e) {
10900       {
10901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (std::exception& e) {
10904       {
10905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (Dali::DaliException e) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10910       };
10911     } catch (...) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10914       };
10915     }
10916   }
10917
10918   jresult = (void *)result;
10919   return jresult;
10920 }
10921
10922
10923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10924   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10925
10926   arg1 = (Dali::Quaternion *)jarg1;
10927   {
10928     try {
10929       delete arg1;
10930     } catch (std::out_of_range& e) {
10931       {
10932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10933       };
10934     } catch (std::exception& e) {
10935       {
10936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10937       };
10938     } catch (Dali::DaliException e) {
10939       {
10940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10941       };
10942     } catch (...) {
10943       {
10944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10945       };
10946     }
10947   }
10948
10949 }
10950
10951
10952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10953   void * jresult ;
10954   Dali::Quaternion *result = 0 ;
10955
10956   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10957   jresult = (void *)result;
10958   return jresult;
10959 }
10960
10961
10962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10963   unsigned int jresult ;
10964   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10965   bool result;
10966
10967   arg1 = (Dali::Quaternion *)jarg1;
10968   {
10969     try {
10970       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10971     } catch (std::out_of_range& e) {
10972       {
10973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10974       };
10975     } catch (std::exception& e) {
10976       {
10977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10978       };
10979     } catch (Dali::DaliException e) {
10980       {
10981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10982       };
10983     } catch (...) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10986       };
10987     }
10988   }
10989
10990   jresult = result;
10991   return jresult;
10992 }
10993
10994
10995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10996   unsigned int jresult ;
10997   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10998   Dali::Vector3 *arg2 = 0 ;
10999   Dali::Radian *arg3 = 0 ;
11000   bool result;
11001
11002   arg1 = (Dali::Quaternion *)jarg1;
11003   arg2 = (Dali::Vector3 *)jarg2;
11004   if (!arg2) {
11005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11006     return 0;
11007   }
11008   arg3 = (Dali::Radian *)jarg3;
11009   if (!arg3) {
11010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11011     return 0;
11012   }
11013   {
11014     try {
11015       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11016     } catch (std::out_of_range& e) {
11017       {
11018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11019       };
11020     } catch (std::exception& e) {
11021       {
11022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (Dali::DaliException e) {
11025       {
11026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11027       };
11028     } catch (...) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11031       };
11032     }
11033   }
11034
11035   jresult = result;
11036   return jresult;
11037 }
11038
11039
11040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11041   void * jresult ;
11042   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11043   Dali::Quaternion *arg2 = 0 ;
11044   Dali::Quaternion result;
11045
11046   arg1 = (Dali::Quaternion *)jarg1;
11047   arg2 = (Dali::Quaternion *)jarg2;
11048   if (!arg2) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11050     return 0;
11051   }
11052   {
11053     try {
11054       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11055     } catch (std::out_of_range& e) {
11056       {
11057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11058       };
11059     } catch (std::exception& e) {
11060       {
11061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11062       };
11063     } catch (Dali::DaliException e) {
11064       {
11065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11066       };
11067     } catch (...) {
11068       {
11069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11070       };
11071     }
11072   }
11073
11074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11075   return jresult;
11076 }
11077
11078
11079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11080   void * jresult ;
11081   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11082   Dali::Quaternion *arg2 = 0 ;
11083   Dali::Quaternion result;
11084
11085   arg1 = (Dali::Quaternion *)jarg1;
11086   arg2 = (Dali::Quaternion *)jarg2;
11087   if (!arg2) {
11088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11089     return 0;
11090   }
11091   {
11092     try {
11093       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11094     } catch (std::out_of_range& e) {
11095       {
11096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11097       };
11098     } catch (std::exception& e) {
11099       {
11100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11101       };
11102     } catch (Dali::DaliException e) {
11103       {
11104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11105       };
11106     } catch (...) {
11107       {
11108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11109       };
11110     }
11111   }
11112
11113   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11119   void * jresult ;
11120   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11121   Dali::Quaternion *arg2 = 0 ;
11122   Dali::Quaternion result;
11123
11124   arg1 = (Dali::Quaternion *)jarg1;
11125   arg2 = (Dali::Quaternion *)jarg2;
11126   if (!arg2) {
11127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11128     return 0;
11129   }
11130   {
11131     try {
11132       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11133     } catch (std::out_of_range& e) {
11134       {
11135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11136       };
11137     } catch (std::exception& e) {
11138       {
11139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11140       };
11141     } catch (Dali::DaliException e) {
11142       {
11143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11144       };
11145     } catch (...) {
11146       {
11147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11148       };
11149     }
11150   }
11151
11152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11153   return jresult;
11154 }
11155
11156
11157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11158   void * jresult ;
11159   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11160   Dali::Vector3 *arg2 = 0 ;
11161   Dali::Vector3 result;
11162
11163   arg1 = (Dali::Quaternion *)jarg1;
11164   arg2 = (Dali::Vector3 *)jarg2;
11165   if (!arg2) {
11166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11167     return 0;
11168   }
11169   {
11170     try {
11171       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11172     } catch (std::out_of_range& e) {
11173       {
11174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11175       };
11176     } catch (std::exception& e) {
11177       {
11178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11179       };
11180     } catch (Dali::DaliException e) {
11181       {
11182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11183       };
11184     } catch (...) {
11185       {
11186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11187       };
11188     }
11189   }
11190
11191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11192   return jresult;
11193 }
11194
11195
11196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11197   void * jresult ;
11198   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11199   Dali::Quaternion *arg2 = 0 ;
11200   Dali::Quaternion result;
11201
11202   arg1 = (Dali::Quaternion *)jarg1;
11203   arg2 = (Dali::Quaternion *)jarg2;
11204   if (!arg2) {
11205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11206     return 0;
11207   }
11208   {
11209     try {
11210       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11211     } catch (std::out_of_range& e) {
11212       {
11213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11214       };
11215     } catch (std::exception& e) {
11216       {
11217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (Dali::DaliException e) {
11220       {
11221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11226       };
11227     }
11228   }
11229
11230   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11231   return jresult;
11232 }
11233
11234
11235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11236   void * jresult ;
11237   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11238   float arg2 ;
11239   Dali::Quaternion result;
11240
11241   arg1 = (Dali::Quaternion *)jarg1;
11242   arg2 = (float)jarg2;
11243   {
11244     try {
11245       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11246     } catch (std::out_of_range& e) {
11247       {
11248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (std::exception& e) {
11251       {
11252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11253       };
11254     } catch (Dali::DaliException e) {
11255       {
11256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11257       };
11258     } catch (...) {
11259       {
11260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11261       };
11262     }
11263   }
11264
11265   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11266   return jresult;
11267 }
11268
11269
11270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11271   void * jresult ;
11272   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11273   float arg2 ;
11274   Dali::Quaternion result;
11275
11276   arg1 = (Dali::Quaternion *)jarg1;
11277   arg2 = (float)jarg2;
11278   {
11279     try {
11280       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11281     } catch (std::out_of_range& e) {
11282       {
11283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11284       };
11285     } catch (std::exception& e) {
11286       {
11287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11288       };
11289     } catch (Dali::DaliException e) {
11290       {
11291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11292       };
11293     } catch (...) {
11294       {
11295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11296       };
11297     }
11298   }
11299
11300   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11301   return jresult;
11302 }
11303
11304
11305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11306   void * jresult ;
11307   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11308   Dali::Quaternion result;
11309
11310   arg1 = (Dali::Quaternion *)jarg1;
11311   {
11312     try {
11313       result = ((Dali::Quaternion const *)arg1)->operator -();
11314     } catch (std::out_of_range& e) {
11315       {
11316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11317       };
11318     } catch (std::exception& e) {
11319       {
11320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11321       };
11322     } catch (Dali::DaliException e) {
11323       {
11324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11325       };
11326     } catch (...) {
11327       {
11328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11329       };
11330     }
11331   }
11332
11333   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11334   return jresult;
11335 }
11336
11337
11338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11339   void * jresult ;
11340   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11341   Dali::Quaternion *arg2 = 0 ;
11342   Dali::Quaternion *result = 0 ;
11343
11344   arg1 = (Dali::Quaternion *)jarg1;
11345   arg2 = (Dali::Quaternion *)jarg2;
11346   if (!arg2) {
11347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11348     return 0;
11349   }
11350   {
11351     try {
11352       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11353     } catch (std::out_of_range& e) {
11354       {
11355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11356       };
11357     } catch (std::exception& e) {
11358       {
11359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11360       };
11361     } catch (Dali::DaliException e) {
11362       {
11363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11364       };
11365     } catch (...) {
11366       {
11367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11368       };
11369     }
11370   }
11371
11372   jresult = (void *)result;
11373   return jresult;
11374 }
11375
11376
11377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11378   void * jresult ;
11379   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11380   Dali::Quaternion *arg2 = 0 ;
11381   Dali::Quaternion *result = 0 ;
11382
11383   arg1 = (Dali::Quaternion *)jarg1;
11384   arg2 = (Dali::Quaternion *)jarg2;
11385   if (!arg2) {
11386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11387     return 0;
11388   }
11389   {
11390     try {
11391       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11392     } catch (std::out_of_range& e) {
11393       {
11394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11395       };
11396     } catch (std::exception& e) {
11397       {
11398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (Dali::DaliException e) {
11401       {
11402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11403       };
11404     } catch (...) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11407       };
11408     }
11409   }
11410
11411   jresult = (void *)result;
11412   return jresult;
11413 }
11414
11415
11416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11417   void * jresult ;
11418   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11419   Dali::Quaternion *arg2 = 0 ;
11420   Dali::Quaternion *result = 0 ;
11421
11422   arg1 = (Dali::Quaternion *)jarg1;
11423   arg2 = (Dali::Quaternion *)jarg2;
11424   if (!arg2) {
11425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11426     return 0;
11427   }
11428   {
11429     try {
11430       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11431     } catch (std::out_of_range& e) {
11432       {
11433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11434       };
11435     } catch (std::exception& e) {
11436       {
11437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11438       };
11439     } catch (Dali::DaliException e) {
11440       {
11441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11442       };
11443     } catch (...) {
11444       {
11445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11446       };
11447     }
11448   }
11449
11450   jresult = (void *)result;
11451   return jresult;
11452 }
11453
11454
11455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11456   void * jresult ;
11457   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11458   float arg2 ;
11459   Dali::Quaternion *result = 0 ;
11460
11461   arg1 = (Dali::Quaternion *)jarg1;
11462   arg2 = (float)jarg2;
11463   {
11464     try {
11465       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11466     } catch (std::out_of_range& e) {
11467       {
11468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11469       };
11470     } catch (std::exception& e) {
11471       {
11472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11473       };
11474     } catch (Dali::DaliException e) {
11475       {
11476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11477       };
11478     } catch (...) {
11479       {
11480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11481       };
11482     }
11483   }
11484
11485   jresult = (void *)result;
11486   return jresult;
11487 }
11488
11489
11490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11491   void * jresult ;
11492   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11493   float arg2 ;
11494   Dali::Quaternion *result = 0 ;
11495
11496   arg1 = (Dali::Quaternion *)jarg1;
11497   arg2 = (float)jarg2;
11498   {
11499     try {
11500       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11501     } catch (std::out_of_range& e) {
11502       {
11503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11504       };
11505     } catch (std::exception& e) {
11506       {
11507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11508       };
11509     } catch (Dali::DaliException e) {
11510       {
11511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11512       };
11513     } catch (...) {
11514       {
11515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11516       };
11517     }
11518   }
11519
11520   jresult = (void *)result;
11521   return jresult;
11522 }
11523
11524
11525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11526   unsigned int jresult ;
11527   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11528   Dali::Quaternion *arg2 = 0 ;
11529   bool result;
11530
11531   arg1 = (Dali::Quaternion *)jarg1;
11532   arg2 = (Dali::Quaternion *)jarg2;
11533   if (!arg2) {
11534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11535     return 0;
11536   }
11537   {
11538     try {
11539       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11540     } catch (std::out_of_range& e) {
11541       {
11542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11543       };
11544     } catch (std::exception& e) {
11545       {
11546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11547       };
11548     } catch (Dali::DaliException e) {
11549       {
11550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11551       };
11552     } catch (...) {
11553       {
11554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11555       };
11556     }
11557   }
11558
11559   jresult = result;
11560   return jresult;
11561 }
11562
11563
11564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11565   unsigned int jresult ;
11566   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11567   Dali::Quaternion *arg2 = 0 ;
11568   bool result;
11569
11570   arg1 = (Dali::Quaternion *)jarg1;
11571   arg2 = (Dali::Quaternion *)jarg2;
11572   if (!arg2) {
11573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11574     return 0;
11575   }
11576   {
11577     try {
11578       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11579     } catch (std::out_of_range& e) {
11580       {
11581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11582       };
11583     } catch (std::exception& e) {
11584       {
11585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11586       };
11587     } catch (Dali::DaliException e) {
11588       {
11589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11590       };
11591     } catch (...) {
11592       {
11593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11594       };
11595     }
11596   }
11597
11598   jresult = result;
11599   return jresult;
11600 }
11601
11602
11603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11604   float jresult ;
11605   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11606   float result;
11607
11608   arg1 = (Dali::Quaternion *)jarg1;
11609   {
11610     try {
11611       result = (float)((Dali::Quaternion const *)arg1)->Length();
11612     } catch (std::out_of_range& e) {
11613       {
11614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11615       };
11616     } catch (std::exception& e) {
11617       {
11618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11619       };
11620     } catch (Dali::DaliException e) {
11621       {
11622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11623       };
11624     } catch (...) {
11625       {
11626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11627       };
11628     }
11629   }
11630
11631   jresult = result;
11632   return jresult;
11633 }
11634
11635
11636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11637   float jresult ;
11638   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11639   float result;
11640
11641   arg1 = (Dali::Quaternion *)jarg1;
11642   {
11643     try {
11644       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11645     } catch (std::out_of_range& e) {
11646       {
11647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11648       };
11649     } catch (std::exception& e) {
11650       {
11651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11652       };
11653     } catch (Dali::DaliException e) {
11654       {
11655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11656       };
11657     } catch (...) {
11658       {
11659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11660       };
11661     }
11662   }
11663
11664   jresult = result;
11665   return jresult;
11666 }
11667
11668
11669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11670   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11671
11672   arg1 = (Dali::Quaternion *)jarg1;
11673   {
11674     try {
11675       (arg1)->Normalize();
11676     } catch (std::out_of_range& e) {
11677       {
11678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11679       };
11680     } catch (std::exception& e) {
11681       {
11682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11683       };
11684     } catch (Dali::DaliException e) {
11685       {
11686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11687       };
11688     } catch (...) {
11689       {
11690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11691       };
11692     }
11693   }
11694
11695 }
11696
11697
11698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11699   void * jresult ;
11700   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11701   Dali::Quaternion result;
11702
11703   arg1 = (Dali::Quaternion *)jarg1;
11704   {
11705     try {
11706       result = ((Dali::Quaternion const *)arg1)->Normalized();
11707     } catch (std::out_of_range& e) {
11708       {
11709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11710       };
11711     } catch (std::exception& e) {
11712       {
11713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11714       };
11715     } catch (Dali::DaliException e) {
11716       {
11717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11718       };
11719     } catch (...) {
11720       {
11721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11722       };
11723     }
11724   }
11725
11726   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11727   return jresult;
11728 }
11729
11730
11731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11732   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11733
11734   arg1 = (Dali::Quaternion *)jarg1;
11735   {
11736     try {
11737       (arg1)->Conjugate();
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11745       };
11746     } catch (Dali::DaliException e) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11749       };
11750     } catch (...) {
11751       {
11752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11753       };
11754     }
11755   }
11756
11757 }
11758
11759
11760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11761   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11762
11763   arg1 = (Dali::Quaternion *)jarg1;
11764   {
11765     try {
11766       (arg1)->Invert();
11767     } catch (std::out_of_range& e) {
11768       {
11769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11770       };
11771     } catch (std::exception& e) {
11772       {
11773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (Dali::DaliException e) {
11776       {
11777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11778       };
11779     } catch (...) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11782       };
11783     }
11784   }
11785
11786 }
11787
11788
11789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11790   void * jresult ;
11791   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11792   Dali::Quaternion result;
11793
11794   arg1 = (Dali::Quaternion *)jarg1;
11795   {
11796     try {
11797       result = ((Dali::Quaternion const *)arg1)->Log();
11798     } catch (std::out_of_range& e) {
11799       {
11800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11801       };
11802     } catch (std::exception& e) {
11803       {
11804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11805       };
11806     } catch (Dali::DaliException e) {
11807       {
11808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11809       };
11810     } catch (...) {
11811       {
11812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11813       };
11814     }
11815   }
11816
11817   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11818   return jresult;
11819 }
11820
11821
11822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11823   void * jresult ;
11824   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11825   Dali::Quaternion result;
11826
11827   arg1 = (Dali::Quaternion *)jarg1;
11828   {
11829     try {
11830       result = ((Dali::Quaternion const *)arg1)->Exp();
11831     } catch (std::out_of_range& e) {
11832       {
11833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11834       };
11835     } catch (std::exception& e) {
11836       {
11837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11838       };
11839     } catch (Dali::DaliException e) {
11840       {
11841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11842       };
11843     } catch (...) {
11844       {
11845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11846       };
11847     }
11848   }
11849
11850   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11851   return jresult;
11852 }
11853
11854
11855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11856   float jresult ;
11857   Dali::Quaternion *arg1 = 0 ;
11858   Dali::Quaternion *arg2 = 0 ;
11859   float result;
11860
11861   arg1 = (Dali::Quaternion *)jarg1;
11862   if (!arg1) {
11863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11864     return 0;
11865   }
11866   arg2 = (Dali::Quaternion *)jarg2;
11867   if (!arg2) {
11868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11869     return 0;
11870   }
11871   {
11872     try {
11873       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11874     } catch (std::out_of_range& e) {
11875       {
11876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (std::exception& e) {
11879       {
11880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (Dali::DaliException e) {
11883       {
11884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11885       };
11886     } catch (...) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11889       };
11890     }
11891   }
11892
11893   jresult = result;
11894   return jresult;
11895 }
11896
11897
11898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11899   void * jresult ;
11900   Dali::Quaternion *arg1 = 0 ;
11901   Dali::Quaternion *arg2 = 0 ;
11902   float arg3 ;
11903   Dali::Quaternion result;
11904
11905   arg1 = (Dali::Quaternion *)jarg1;
11906   if (!arg1) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11908     return 0;
11909   }
11910   arg2 = (Dali::Quaternion *)jarg2;
11911   if (!arg2) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg3 = (float)jarg3;
11916   {
11917     try {
11918       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11919     } catch (std::out_of_range& e) {
11920       {
11921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (std::exception& e) {
11924       {
11925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (Dali::DaliException e) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11930       };
11931     } catch (...) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11934       };
11935     }
11936   }
11937
11938   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11939   return jresult;
11940 }
11941
11942
11943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11944   void * jresult ;
11945   Dali::Quaternion *arg1 = 0 ;
11946   Dali::Quaternion *arg2 = 0 ;
11947   float arg3 ;
11948   Dali::Quaternion result;
11949
11950   arg1 = (Dali::Quaternion *)jarg1;
11951   if (!arg1) {
11952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11953     return 0;
11954   }
11955   arg2 = (Dali::Quaternion *)jarg2;
11956   if (!arg2) {
11957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11958     return 0;
11959   }
11960   arg3 = (float)jarg3;
11961   {
11962     try {
11963       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11964     } catch (std::out_of_range& e) {
11965       {
11966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11967       };
11968     } catch (std::exception& e) {
11969       {
11970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (Dali::DaliException e) {
11973       {
11974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11975       };
11976     } catch (...) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11979       };
11980     }
11981   }
11982
11983   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11984   return jresult;
11985 }
11986
11987
11988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11989   void * jresult ;
11990   Dali::Quaternion *arg1 = 0 ;
11991   Dali::Quaternion *arg2 = 0 ;
11992   float arg3 ;
11993   Dali::Quaternion result;
11994
11995   arg1 = (Dali::Quaternion *)jarg1;
11996   if (!arg1) {
11997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11998     return 0;
11999   }
12000   arg2 = (Dali::Quaternion *)jarg2;
12001   if (!arg2) {
12002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12003     return 0;
12004   }
12005   arg3 = (float)jarg3;
12006   {
12007     try {
12008       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12009     } catch (std::out_of_range& e) {
12010       {
12011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12012       };
12013     } catch (std::exception& e) {
12014       {
12015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (Dali::DaliException e) {
12018       {
12019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027
12028   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12034   void * jresult ;
12035   Dali::Quaternion *arg1 = 0 ;
12036   Dali::Quaternion *arg2 = 0 ;
12037   Dali::Quaternion *arg3 = 0 ;
12038   Dali::Quaternion *arg4 = 0 ;
12039   float arg5 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (Dali::Quaternion *)jarg3;
12053   if (!arg3) {
12054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12055     return 0;
12056   }
12057   arg4 = (Dali::Quaternion *)jarg4;
12058   if (!arg4) {
12059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12060     return 0;
12061   }
12062   arg5 = (float)jarg5;
12063   {
12064     try {
12065       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12066     } catch (std::out_of_range& e) {
12067       {
12068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12069       };
12070     } catch (std::exception& e) {
12071       {
12072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12073       };
12074     } catch (Dali::DaliException e) {
12075       {
12076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12077       };
12078     } catch (...) {
12079       {
12080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12081       };
12082     }
12083   }
12084
12085   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12086   return jresult;
12087 }
12088
12089
12090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12091   float jresult ;
12092   Dali::Quaternion *arg1 = 0 ;
12093   Dali::Quaternion *arg2 = 0 ;
12094   float result;
12095
12096   arg1 = (Dali::Quaternion *)jarg1;
12097   if (!arg1) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg2 = (Dali::Quaternion *)jarg2;
12102   if (!arg2) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   {
12107     try {
12108       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12109     } catch (std::out_of_range& e) {
12110       {
12111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12112       };
12113     } catch (std::exception& e) {
12114       {
12115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (Dali::DaliException e) {
12118       {
12119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127
12128   jresult = result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12134   void * jresult ;
12135   Dali::Matrix *result = 0 ;
12136
12137   {
12138     try {
12139       result = (Dali::Matrix *)new Dali::Matrix();
12140     } catch (std::out_of_range& e) {
12141       {
12142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12143       };
12144     } catch (std::exception& e) {
12145       {
12146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12147       };
12148     } catch (Dali::DaliException e) {
12149       {
12150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12151       };
12152     } catch (...) {
12153       {
12154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12155       };
12156     }
12157   }
12158
12159   jresult = (void *)result;
12160   return jresult;
12161 }
12162
12163
12164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12165   void * jresult ;
12166   bool arg1 ;
12167   Dali::Matrix *result = 0 ;
12168
12169   arg1 = jarg1 ? true : false;
12170   {
12171     try {
12172       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12173     } catch (std::out_of_range& e) {
12174       {
12175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12176       };
12177     } catch (std::exception& e) {
12178       {
12179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12180       };
12181     } catch (Dali::DaliException e) {
12182       {
12183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12184       };
12185     } catch (...) {
12186       {
12187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12188       };
12189     }
12190   }
12191
12192   jresult = (void *)result;
12193   return jresult;
12194 }
12195
12196
12197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12198   void * jresult ;
12199   float *arg1 = (float *) 0 ;
12200   Dali::Matrix *result = 0 ;
12201
12202   arg1 = jarg1;
12203   {
12204     try {
12205       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12206     } catch (std::out_of_range& e) {
12207       {
12208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12209       };
12210     } catch (std::exception& e) {
12211       {
12212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12213       };
12214     } catch (Dali::DaliException e) {
12215       {
12216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12217       };
12218     } catch (...) {
12219       {
12220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12221       };
12222     }
12223   }
12224
12225   jresult = (void *)result;
12226
12227
12228   return jresult;
12229 }
12230
12231
12232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12233   void * jresult ;
12234   Dali::Quaternion *arg1 = 0 ;
12235   Dali::Matrix *result = 0 ;
12236
12237   arg1 = (Dali::Quaternion *)jarg1;
12238   if (!arg1) {
12239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12240     return 0;
12241   }
12242   {
12243     try {
12244       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12245     } catch (std::out_of_range& e) {
12246       {
12247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12248       };
12249     } catch (std::exception& e) {
12250       {
12251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12252       };
12253     } catch (Dali::DaliException e) {
12254       {
12255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12256       };
12257     } catch (...) {
12258       {
12259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12260       };
12261     }
12262   }
12263
12264   jresult = (void *)result;
12265   return jresult;
12266 }
12267
12268
12269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12270   void * jresult ;
12271   Dali::Matrix *arg1 = 0 ;
12272   Dali::Matrix *result = 0 ;
12273
12274   arg1 = (Dali::Matrix *)jarg1;
12275   if (!arg1) {
12276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12277     return 0;
12278   }
12279   {
12280     try {
12281       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12282     } catch (std::out_of_range& e) {
12283       {
12284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (std::exception& e) {
12287       {
12288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12289       };
12290     } catch (Dali::DaliException e) {
12291       {
12292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12293       };
12294     } catch (...) {
12295       {
12296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12297       };
12298     }
12299   }
12300
12301   jresult = (void *)result;
12302   return jresult;
12303 }
12304
12305
12306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12307   void * jresult ;
12308   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12309   Dali::Matrix *arg2 = 0 ;
12310   Dali::Matrix *result = 0 ;
12311
12312   arg1 = (Dali::Matrix *)jarg1;
12313   arg2 = (Dali::Matrix *)jarg2;
12314   if (!arg2) {
12315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12316     return 0;
12317   }
12318   {
12319     try {
12320       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12321     } catch (std::out_of_range& e) {
12322       {
12323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12324       };
12325     } catch (std::exception& e) {
12326       {
12327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (Dali::DaliException e) {
12330       {
12331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12332       };
12333     } catch (...) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12336       };
12337     }
12338   }
12339
12340   jresult = (void *)result;
12341   return jresult;
12342 }
12343
12344
12345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12346   void * jresult ;
12347   Dali::Matrix *result = 0 ;
12348
12349   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12356   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   {
12360     try {
12361       (arg1)->SetIdentity();
12362     } catch (std::out_of_range& e) {
12363       {
12364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12365       };
12366     } catch (std::exception& e) {
12367       {
12368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12369       };
12370     } catch (Dali::DaliException e) {
12371       {
12372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12373       };
12374     } catch (...) {
12375       {
12376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12377       };
12378     }
12379   }
12380
12381 }
12382
12383
12384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12385   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12386   Dali::Vector3 *arg2 = 0 ;
12387
12388   arg1 = (Dali::Matrix *)jarg1;
12389   arg2 = (Dali::Vector3 *)jarg2;
12390   if (!arg2) {
12391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12392     return ;
12393   }
12394   {
12395     try {
12396       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12397     } catch (std::out_of_range& e) {
12398       {
12399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12400       };
12401     } catch (std::exception& e) {
12402       {
12403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12404       };
12405     } catch (Dali::DaliException e) {
12406       {
12407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12408       };
12409     } catch (...) {
12410       {
12411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12412       };
12413     }
12414   }
12415
12416 }
12417
12418
12419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12420   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12421   Dali::Matrix *arg2 = 0 ;
12422
12423   arg1 = (Dali::Matrix *)jarg1;
12424   arg2 = (Dali::Matrix *)jarg2;
12425   if (!arg2) {
12426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12427     return ;
12428   }
12429   {
12430     try {
12431       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12432     } catch (std::out_of_range& e) {
12433       {
12434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12435       };
12436     } catch (std::exception& e) {
12437       {
12438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12439       };
12440     } catch (Dali::DaliException e) {
12441       {
12442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12443       };
12444     } catch (...) {
12445       {
12446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12447       };
12448     }
12449   }
12450
12451 }
12452
12453
12454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12455   unsigned int jresult ;
12456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12457   bool result;
12458
12459   arg1 = (Dali::Matrix *)jarg1;
12460   {
12461     try {
12462       result = (bool)(arg1)->Invert();
12463     } catch (std::out_of_range& e) {
12464       {
12465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12466       };
12467     } catch (std::exception& e) {
12468       {
12469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12470       };
12471     } catch (Dali::DaliException e) {
12472       {
12473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12474       };
12475     } catch (...) {
12476       {
12477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12478       };
12479     }
12480   }
12481
12482   jresult = result;
12483   return jresult;
12484 }
12485
12486
12487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12488   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12489
12490   arg1 = (Dali::Matrix *)jarg1;
12491   {
12492     try {
12493       (arg1)->Transpose();
12494     } catch (std::out_of_range& e) {
12495       {
12496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12497       };
12498     } catch (std::exception& e) {
12499       {
12500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12501       };
12502     } catch (Dali::DaliException e) {
12503       {
12504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12505       };
12506     } catch (...) {
12507       {
12508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12509       };
12510     }
12511   }
12512
12513 }
12514
12515
12516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12517   void * jresult ;
12518   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12519   Dali::Vector3 result;
12520
12521   arg1 = (Dali::Matrix *)jarg1;
12522   {
12523     try {
12524       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12525     } catch (std::out_of_range& e) {
12526       {
12527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12528       };
12529     } catch (std::exception& e) {
12530       {
12531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (Dali::DaliException e) {
12534       {
12535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12536       };
12537     } catch (...) {
12538       {
12539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12540       };
12541     }
12542   }
12543
12544   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12545   return jresult;
12546 }
12547
12548
12549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12550   void * jresult ;
12551   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12552   Dali::Vector3 result;
12553
12554   arg1 = (Dali::Matrix *)jarg1;
12555   {
12556     try {
12557       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12558     } catch (std::out_of_range& e) {
12559       {
12560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12561       };
12562     } catch (std::exception& e) {
12563       {
12564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12565       };
12566     } catch (Dali::DaliException e) {
12567       {
12568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12573       };
12574     }
12575   }
12576
12577   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12578   return jresult;
12579 }
12580
12581
12582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12583   void * jresult ;
12584   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12585   Dali::Vector3 result;
12586
12587   arg1 = (Dali::Matrix *)jarg1;
12588   {
12589     try {
12590       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12591     } catch (std::out_of_range& e) {
12592       {
12593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12594       };
12595     } catch (std::exception& e) {
12596       {
12597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (Dali::DaliException e) {
12600       {
12601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12602       };
12603     } catch (...) {
12604       {
12605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12606       };
12607     }
12608   }
12609
12610   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12611   return jresult;
12612 }
12613
12614
12615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12616   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12617   Dali::Vector3 *arg2 = 0 ;
12618
12619   arg1 = (Dali::Matrix *)jarg1;
12620   arg2 = (Dali::Vector3 *)jarg2;
12621   if (!arg2) {
12622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12623     return ;
12624   }
12625   {
12626     try {
12627       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12628     } catch (std::out_of_range& e) {
12629       {
12630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12631       };
12632     } catch (std::exception& e) {
12633       {
12634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12635       };
12636     } catch (Dali::DaliException e) {
12637       {
12638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12639       };
12640     } catch (...) {
12641       {
12642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12643       };
12644     }
12645   }
12646
12647 }
12648
12649
12650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12651   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12652   Dali::Vector3 *arg2 = 0 ;
12653
12654   arg1 = (Dali::Matrix *)jarg1;
12655   arg2 = (Dali::Vector3 *)jarg2;
12656   if (!arg2) {
12657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12658     return ;
12659   }
12660   {
12661     try {
12662       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12663     } catch (std::out_of_range& e) {
12664       {
12665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12666       };
12667     } catch (std::exception& e) {
12668       {
12669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12670       };
12671     } catch (Dali::DaliException e) {
12672       {
12673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12674       };
12675     } catch (...) {
12676       {
12677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12678       };
12679     }
12680   }
12681
12682 }
12683
12684
12685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12686   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12687   Dali::Vector3 *arg2 = 0 ;
12688
12689   arg1 = (Dali::Matrix *)jarg1;
12690   arg2 = (Dali::Vector3 *)jarg2;
12691   if (!arg2) {
12692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12693     return ;
12694   }
12695   {
12696     try {
12697       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12698     } catch (std::out_of_range& e) {
12699       {
12700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12701       };
12702     } catch (std::exception& e) {
12703       {
12704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12705       };
12706     } catch (Dali::DaliException e) {
12707       {
12708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12709       };
12710     } catch (...) {
12711       {
12712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12713       };
12714     }
12715   }
12716
12717 }
12718
12719
12720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12721   void * jresult ;
12722   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12723   Dali::Vector4 *result = 0 ;
12724
12725   arg1 = (Dali::Matrix *)jarg1;
12726   {
12727     try {
12728       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12729     } catch (std::out_of_range& e) {
12730       {
12731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12732       };
12733     } catch (std::exception& e) {
12734       {
12735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12736       };
12737     } catch (Dali::DaliException e) {
12738       {
12739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12740       };
12741     } catch (...) {
12742       {
12743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12744       };
12745     }
12746   }
12747
12748   jresult = (void *)result;
12749   return jresult;
12750 }
12751
12752
12753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12754   void * jresult ;
12755   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12756   Dali::Vector3 *result = 0 ;
12757
12758   arg1 = (Dali::Matrix *)jarg1;
12759   {
12760     try {
12761       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12762     } catch (std::out_of_range& e) {
12763       {
12764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12765       };
12766     } catch (std::exception& e) {
12767       {
12768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12769       };
12770     } catch (Dali::DaliException e) {
12771       {
12772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12773       };
12774     } catch (...) {
12775       {
12776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12777       };
12778     }
12779   }
12780
12781   jresult = (void *)result;
12782   return jresult;
12783 }
12784
12785
12786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12787   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12788   Dali::Vector4 *arg2 = 0 ;
12789
12790   arg1 = (Dali::Matrix *)jarg1;
12791   arg2 = (Dali::Vector4 *)jarg2;
12792   if (!arg2) {
12793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12794     return ;
12795   }
12796   {
12797     try {
12798       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12799     } catch (std::out_of_range& e) {
12800       {
12801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12802       };
12803     } catch (std::exception& e) {
12804       {
12805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12806       };
12807     } catch (Dali::DaliException e) {
12808       {
12809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12810       };
12811     } catch (...) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12814       };
12815     }
12816   }
12817
12818 }
12819
12820
12821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12822   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12823   Dali::Vector3 *arg2 = 0 ;
12824
12825   arg1 = (Dali::Matrix *)jarg1;
12826   arg2 = (Dali::Vector3 *)jarg2;
12827   if (!arg2) {
12828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12829     return ;
12830   }
12831   {
12832     try {
12833       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12834     } catch (std::out_of_range& e) {
12835       {
12836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12837       };
12838     } catch (std::exception& e) {
12839       {
12840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12841       };
12842     } catch (Dali::DaliException e) {
12843       {
12844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12845       };
12846     } catch (...) {
12847       {
12848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12849       };
12850     }
12851   }
12852
12853 }
12854
12855
12856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12857   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12858
12859   arg1 = (Dali::Matrix *)jarg1;
12860   {
12861     try {
12862       (arg1)->OrthoNormalize();
12863     } catch (std::out_of_range& e) {
12864       {
12865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12866       };
12867     } catch (std::exception& e) {
12868       {
12869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12870       };
12871     } catch (Dali::DaliException e) {
12872       {
12873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12874       };
12875     } catch (...) {
12876       {
12877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12878       };
12879     }
12880   }
12881
12882 }
12883
12884
12885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12886   void * jresult ;
12887   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12888   float *result = 0 ;
12889
12890   arg1 = (Dali::Matrix *)jarg1;
12891   {
12892     try {
12893       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12894     } catch (std::out_of_range& e) {
12895       {
12896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12897       };
12898     } catch (std::exception& e) {
12899       {
12900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12901       };
12902     } catch (Dali::DaliException e) {
12903       {
12904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12905       };
12906     } catch (...) {
12907       {
12908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12909       };
12910     }
12911   }
12912
12913   jresult = (void *)result;
12914   return jresult;
12915 }
12916
12917
12918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12919   Dali::Matrix *arg1 = 0 ;
12920   Dali::Matrix *arg2 = 0 ;
12921   Dali::Matrix *arg3 = 0 ;
12922
12923   arg1 = (Dali::Matrix *)jarg1;
12924   if (!arg1) {
12925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12926     return ;
12927   }
12928   arg2 = (Dali::Matrix *)jarg2;
12929   if (!arg2) {
12930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12931     return ;
12932   }
12933   arg3 = (Dali::Matrix *)jarg3;
12934   if (!arg3) {
12935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12936     return ;
12937   }
12938   {
12939     try {
12940       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12956       };
12957     }
12958   }
12959
12960 }
12961
12962
12963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12964   Dali::Matrix *arg1 = 0 ;
12965   Dali::Matrix *arg2 = 0 ;
12966   Dali::Quaternion *arg3 = 0 ;
12967
12968   arg1 = (Dali::Matrix *)jarg1;
12969   if (!arg1) {
12970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12971     return ;
12972   }
12973   arg2 = (Dali::Matrix *)jarg2;
12974   if (!arg2) {
12975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12976     return ;
12977   }
12978   arg3 = (Dali::Quaternion *)jarg3;
12979   if (!arg3) {
12980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12981     return ;
12982   }
12983   {
12984     try {
12985       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12986     } catch (std::out_of_range& e) {
12987       {
12988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12989       };
12990     } catch (std::exception& e) {
12991       {
12992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (Dali::DaliException e) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12997       };
12998     } catch (...) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13001       };
13002     }
13003   }
13004
13005 }
13006
13007
13008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13009   void * jresult ;
13010   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13011   Dali::Vector4 *arg2 = 0 ;
13012   Dali::Vector4 result;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   arg2 = (Dali::Vector4 *)jarg2;
13016   if (!arg2) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13018     return 0;
13019   }
13020   {
13021     try {
13022       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13023     } catch (std::out_of_range& e) {
13024       {
13025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13026       };
13027     } catch (std::exception& e) {
13028       {
13029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13030       };
13031     } catch (Dali::DaliException e) {
13032       {
13033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13034       };
13035     } catch (...) {
13036       {
13037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13038       };
13039     }
13040   }
13041
13042   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13043   return jresult;
13044 }
13045
13046
13047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13048   unsigned int jresult ;
13049   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13050   Dali::Matrix *arg2 = 0 ;
13051   bool result;
13052
13053   arg1 = (Dali::Matrix *)jarg1;
13054   arg2 = (Dali::Matrix *)jarg2;
13055   if (!arg2) {
13056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13057     return 0;
13058   }
13059   {
13060     try {
13061       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13062     } catch (std::out_of_range& e) {
13063       {
13064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13065       };
13066     } catch (std::exception& e) {
13067       {
13068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13069       };
13070     } catch (Dali::DaliException e) {
13071       {
13072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13073       };
13074     } catch (...) {
13075       {
13076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13077       };
13078     }
13079   }
13080
13081   jresult = result;
13082   return jresult;
13083 }
13084
13085
13086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13087   unsigned int jresult ;
13088   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13089   Dali::Matrix *arg2 = 0 ;
13090   bool result;
13091
13092   arg1 = (Dali::Matrix *)jarg1;
13093   arg2 = (Dali::Matrix *)jarg2;
13094   if (!arg2) {
13095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13096     return 0;
13097   }
13098   {
13099     try {
13100       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13101     } catch (std::out_of_range& e) {
13102       {
13103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13104       };
13105     } catch (std::exception& e) {
13106       {
13107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13108       };
13109     } catch (Dali::DaliException e) {
13110       {
13111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13112       };
13113     } catch (...) {
13114       {
13115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13116       };
13117     }
13118   }
13119
13120   jresult = result;
13121   return jresult;
13122 }
13123
13124
13125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13126   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13127   Dali::Vector3 *arg2 = 0 ;
13128   Dali::Quaternion *arg3 = 0 ;
13129   Dali::Vector3 *arg4 = 0 ;
13130
13131   arg1 = (Dali::Matrix *)jarg1;
13132   arg2 = (Dali::Vector3 *)jarg2;
13133   if (!arg2) {
13134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13135     return ;
13136   }
13137   arg3 = (Dali::Quaternion *)jarg3;
13138   if (!arg3) {
13139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13140     return ;
13141   }
13142   arg4 = (Dali::Vector3 *)jarg4;
13143   if (!arg4) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13145     return ;
13146   }
13147   {
13148     try {
13149       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13165       };
13166     }
13167   }
13168
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Vector3 *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224   Dali::Vector3 *arg5 = 0 ;
13225
13226   arg1 = (Dali::Matrix *)jarg1;
13227   arg2 = (Dali::Vector3 *)jarg2;
13228   if (!arg2) {
13229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13230     return ;
13231   }
13232   arg3 = (Dali::Vector3 *)jarg3;
13233   if (!arg3) {
13234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13235     return ;
13236   }
13237   arg4 = (Dali::Vector3 *)jarg4;
13238   if (!arg4) {
13239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13240     return ;
13241   }
13242   arg5 = (Dali::Vector3 *)jarg5;
13243   if (!arg5) {
13244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13245     return ;
13246   }
13247   {
13248     try {
13249       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13250     } catch (std::out_of_range& e) {
13251       {
13252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (std::exception& e) {
13255       {
13256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13257       };
13258     } catch (Dali::DaliException e) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13261       };
13262     } catch (...) {
13263       {
13264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13265       };
13266     }
13267   }
13268
13269 }
13270
13271
13272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13273   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13274   Dali::Vector3 *arg2 = 0 ;
13275   Dali::Quaternion *arg3 = 0 ;
13276   Dali::Vector3 *arg4 = 0 ;
13277
13278   arg1 = (Dali::Matrix *)jarg1;
13279   arg2 = (Dali::Vector3 *)jarg2;
13280   if (!arg2) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13282     return ;
13283   }
13284   arg3 = (Dali::Quaternion *)jarg3;
13285   if (!arg3) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13287     return ;
13288   }
13289   arg4 = (Dali::Vector3 *)jarg4;
13290   if (!arg4) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321
13322   arg1 = (Dali::Matrix *)jarg1;
13323   {
13324     try {
13325       delete arg1;
13326     } catch (std::out_of_range& e) {
13327       {
13328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13329       };
13330     } catch (std::exception& e) {
13331       {
13332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13333       };
13334     } catch (Dali::DaliException e) {
13335       {
13336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13337       };
13338     } catch (...) {
13339       {
13340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13341       };
13342     }
13343   }
13344
13345 }
13346
13347
13348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13349   void * jresult ;
13350   Dali::Matrix3 *result = 0 ;
13351
13352   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13353   jresult = (void *)result;
13354   return jresult;
13355 }
13356
13357
13358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13359   void * jresult ;
13360   Dali::Matrix3 *result = 0 ;
13361
13362   {
13363     try {
13364       result = (Dali::Matrix3 *)new Dali::Matrix3();
13365     } catch (std::out_of_range& e) {
13366       {
13367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13368       };
13369     } catch (std::exception& e) {
13370       {
13371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13372       };
13373     } catch (Dali::DaliException e) {
13374       {
13375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13376       };
13377     } catch (...) {
13378       {
13379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13380       };
13381     }
13382   }
13383
13384   jresult = (void *)result;
13385   return jresult;
13386 }
13387
13388
13389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13390   void * jresult ;
13391   Dali::Matrix3 *arg1 = 0 ;
13392   Dali::Matrix3 *result = 0 ;
13393
13394   arg1 = (Dali::Matrix3 *)jarg1;
13395   if (!arg1) {
13396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13397     return 0;
13398   }
13399   {
13400     try {
13401       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13402     } catch (std::out_of_range& e) {
13403       {
13404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13405       };
13406     } catch (std::exception& e) {
13407       {
13408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13409       };
13410     } catch (Dali::DaliException e) {
13411       {
13412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13413       };
13414     } catch (...) {
13415       {
13416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13417       };
13418     }
13419   }
13420
13421   jresult = (void *)result;
13422   return jresult;
13423 }
13424
13425
13426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13427   void * jresult ;
13428   Dali::Matrix *arg1 = 0 ;
13429   Dali::Matrix3 *result = 0 ;
13430
13431   arg1 = (Dali::Matrix *)jarg1;
13432   if (!arg1) {
13433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13434     return 0;
13435   }
13436   {
13437     try {
13438       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13439     } catch (std::out_of_range& e) {
13440       {
13441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13442       };
13443     } catch (std::exception& e) {
13444       {
13445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13446       };
13447     } catch (Dali::DaliException e) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13450       };
13451     } catch (...) {
13452       {
13453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13454       };
13455     }
13456   }
13457
13458   jresult = (void *)result;
13459   return jresult;
13460 }
13461
13462
13463 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) {
13464   void * jresult ;
13465   float arg1 ;
13466   float arg2 ;
13467   float arg3 ;
13468   float arg4 ;
13469   float arg5 ;
13470   float arg6 ;
13471   float arg7 ;
13472   float arg8 ;
13473   float arg9 ;
13474   Dali::Matrix3 *result = 0 ;
13475
13476   arg1 = (float)jarg1;
13477   arg2 = (float)jarg2;
13478   arg3 = (float)jarg3;
13479   arg4 = (float)jarg4;
13480   arg5 = (float)jarg5;
13481   arg6 = (float)jarg6;
13482   arg7 = (float)jarg7;
13483   arg8 = (float)jarg8;
13484   arg9 = (float)jarg9;
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13513   void * jresult ;
13514   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13515   Dali::Matrix3 *arg2 = 0 ;
13516   Dali::Matrix3 *result = 0 ;
13517
13518   arg1 = (Dali::Matrix3 *)jarg1;
13519   arg2 = (Dali::Matrix3 *)jarg2;
13520   if (!arg2) {
13521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13522     return 0;
13523   }
13524   {
13525     try {
13526       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13527     } catch (std::out_of_range& e) {
13528       {
13529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13530       };
13531     } catch (std::exception& e) {
13532       {
13533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (Dali::DaliException e) {
13536       {
13537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13538       };
13539     } catch (...) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13542       };
13543     }
13544   }
13545
13546   jresult = (void *)result;
13547   return jresult;
13548 }
13549
13550
13551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13552   void * jresult ;
13553   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13554   Dali::Matrix *arg2 = 0 ;
13555   Dali::Matrix3 *result = 0 ;
13556
13557   arg1 = (Dali::Matrix3 *)jarg1;
13558   arg2 = (Dali::Matrix *)jarg2;
13559   if (!arg2) {
13560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13561     return 0;
13562   }
13563   {
13564     try {
13565       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13566     } catch (std::out_of_range& e) {
13567       {
13568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13569       };
13570     } catch (std::exception& e) {
13571       {
13572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13573       };
13574     } catch (Dali::DaliException e) {
13575       {
13576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13577       };
13578     } catch (...) {
13579       {
13580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13581       };
13582     }
13583   }
13584
13585   jresult = (void *)result;
13586   return jresult;
13587 }
13588
13589
13590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13591   unsigned int jresult ;
13592   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13593   Dali::Matrix3 *arg2 = 0 ;
13594   bool result;
13595
13596   arg1 = (Dali::Matrix3 *)jarg1;
13597   arg2 = (Dali::Matrix3 *)jarg2;
13598   if (!arg2) {
13599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13600     return 0;
13601   }
13602   {
13603     try {
13604       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13605     } catch (std::out_of_range& e) {
13606       {
13607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13608       };
13609     } catch (std::exception& e) {
13610       {
13611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13612       };
13613     } catch (Dali::DaliException e) {
13614       {
13615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13616       };
13617     } catch (...) {
13618       {
13619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13620       };
13621     }
13622   }
13623
13624   jresult = result;
13625   return jresult;
13626 }
13627
13628
13629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13630   unsigned int jresult ;
13631   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13632   Dali::Matrix3 *arg2 = 0 ;
13633   bool result;
13634
13635   arg1 = (Dali::Matrix3 *)jarg1;
13636   arg2 = (Dali::Matrix3 *)jarg2;
13637   if (!arg2) {
13638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13639     return 0;
13640   }
13641   {
13642     try {
13643       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (Dali::DaliException e) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13655       };
13656     } catch (...) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13659       };
13660     }
13661   }
13662
13663   jresult = result;
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13669   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13670
13671   arg1 = (Dali::Matrix3 *)jarg1;
13672   {
13673     try {
13674       delete arg1;
13675     } catch (std::out_of_range& e) {
13676       {
13677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13678       };
13679     } catch (std::exception& e) {
13680       {
13681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13682       };
13683     } catch (Dali::DaliException e) {
13684       {
13685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13686       };
13687     } catch (...) {
13688       {
13689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13690       };
13691     }
13692   }
13693
13694 }
13695
13696
13697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13698   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13699
13700   arg1 = (Dali::Matrix3 *)jarg1;
13701   {
13702     try {
13703       (arg1)->SetIdentity();
13704     } catch (std::out_of_range& e) {
13705       {
13706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13707       };
13708     } catch (std::exception& e) {
13709       {
13710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13711       };
13712     } catch (Dali::DaliException e) {
13713       {
13714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13715       };
13716     } catch (...) {
13717       {
13718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13719       };
13720     }
13721   }
13722
13723 }
13724
13725
13726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13727   void * jresult ;
13728   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13729   float *result = 0 ;
13730
13731   arg1 = (Dali::Matrix3 *)jarg1;
13732   {
13733     try {
13734       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13735     } catch (std::out_of_range& e) {
13736       {
13737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13738       };
13739     } catch (std::exception& e) {
13740       {
13741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13742       };
13743     } catch (Dali::DaliException e) {
13744       {
13745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13746       };
13747     } catch (...) {
13748       {
13749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13750       };
13751     }
13752   }
13753
13754   jresult = (void *)result;
13755   return jresult;
13756 }
13757
13758
13759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13760   unsigned int jresult ;
13761   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13762   bool result;
13763
13764   arg1 = (Dali::Matrix3 *)jarg1;
13765   {
13766     try {
13767       result = (bool)(arg1)->Invert();
13768     } catch (std::out_of_range& e) {
13769       {
13770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13771       };
13772     } catch (std::exception& e) {
13773       {
13774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (Dali::DaliException e) {
13777       {
13778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13779       };
13780     } catch (...) {
13781       {
13782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13783       };
13784     }
13785   }
13786
13787   jresult = result;
13788   return jresult;
13789 }
13790
13791
13792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13793   unsigned int jresult ;
13794   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13795   bool result;
13796
13797   arg1 = (Dali::Matrix3 *)jarg1;
13798   {
13799     try {
13800       result = (bool)(arg1)->Transpose();
13801     } catch (std::out_of_range& e) {
13802       {
13803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13804       };
13805     } catch (std::exception& e) {
13806       {
13807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (Dali::DaliException e) {
13810       {
13811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13812       };
13813     } catch (...) {
13814       {
13815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13816       };
13817     }
13818   }
13819
13820   jresult = result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13826   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13827   float arg2 ;
13828
13829   arg1 = (Dali::Matrix3 *)jarg1;
13830   arg2 = (float)jarg2;
13831   {
13832     try {
13833       (arg1)->Scale(arg2);
13834     } catch (std::out_of_range& e) {
13835       {
13836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13837       };
13838     } catch (std::exception& e) {
13839       {
13840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13841       };
13842     } catch (Dali::DaliException e) {
13843       {
13844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13845       };
13846     } catch (...) {
13847       {
13848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13849       };
13850     }
13851   }
13852
13853 }
13854
13855
13856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13857   float jresult ;
13858   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13859   float result;
13860
13861   arg1 = (Dali::Matrix3 *)jarg1;
13862   {
13863     try {
13864       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13865     } catch (std::out_of_range& e) {
13866       {
13867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13868       };
13869     } catch (std::exception& e) {
13870       {
13871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13872       };
13873     } catch (Dali::DaliException e) {
13874       {
13875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13876       };
13877     } catch (...) {
13878       {
13879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13880       };
13881     }
13882   }
13883
13884   jresult = result;
13885   return jresult;
13886 }
13887
13888
13889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13890   unsigned int jresult ;
13891   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13892   bool result;
13893
13894   arg1 = (Dali::Matrix3 *)jarg1;
13895   {
13896     try {
13897       result = (bool)(arg1)->ScaledInverseTranspose();
13898     } catch (std::out_of_range& e) {
13899       {
13900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (std::exception& e) {
13903       {
13904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (Dali::DaliException e) {
13907       {
13908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13909       };
13910     } catch (...) {
13911       {
13912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13913       };
13914     }
13915   }
13916
13917   jresult = result;
13918   return jresult;
13919 }
13920
13921
13922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13923   Dali::Matrix3 *arg1 = 0 ;
13924   Dali::Matrix3 *arg2 = 0 ;
13925   Dali::Matrix3 *arg3 = 0 ;
13926
13927   arg1 = (Dali::Matrix3 *)jarg1;
13928   if (!arg1) {
13929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13930     return ;
13931   }
13932   arg2 = (Dali::Matrix3 *)jarg2;
13933   if (!arg2) {
13934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13935     return ;
13936   }
13937   arg3 = (Dali::Matrix3 *)jarg3;
13938   if (!arg3) {
13939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13940     return ;
13941   }
13942   {
13943     try {
13944       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13960       };
13961     }
13962   }
13963
13964 }
13965
13966
13967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13968   float jresult ;
13969   float arg1 ;
13970   float arg2 ;
13971   float result;
13972
13973   arg1 = (float)jarg1;
13974   arg2 = (float)jarg2;
13975   {
13976     try {
13977       result = (float)Dali::Random::Range(arg1,arg2);
13978     } catch (std::out_of_range& e) {
13979       {
13980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13981       };
13982     } catch (std::exception& e) {
13983       {
13984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13985       };
13986     } catch (Dali::DaliException e) {
13987       {
13988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13989       };
13990     } catch (...) {
13991       {
13992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13993       };
13994     }
13995   }
13996
13997   jresult = result;
13998   return jresult;
13999 }
14000
14001
14002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14003   void * jresult ;
14004   Dali::Vector4 result;
14005
14006   {
14007     try {
14008       result = Dali::Random::Axis();
14009     } catch (std::out_of_range& e) {
14010       {
14011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14012       };
14013     } catch (std::exception& e) {
14014       {
14015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14016       };
14017     } catch (Dali::DaliException e) {
14018       {
14019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14020       };
14021     } catch (...) {
14022       {
14023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14024       };
14025     }
14026   }
14027
14028   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14029   return jresult;
14030 }
14031
14032
14033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14034   void * jresult ;
14035   Dali::AngleAxis *result = 0 ;
14036
14037   {
14038     try {
14039       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14040     } catch (std::out_of_range& e) {
14041       {
14042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14043       };
14044     } catch (std::exception& e) {
14045       {
14046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14047       };
14048     } catch (Dali::DaliException e) {
14049       {
14050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14051       };
14052     } catch (...) {
14053       {
14054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14055       };
14056     }
14057   }
14058
14059   jresult = (void *)result;
14060   return jresult;
14061 }
14062
14063
14064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14065   void * jresult ;
14066   Dali::Radian arg1 ;
14067   Dali::Vector3 *arg2 = 0 ;
14068   Dali::Radian *argp1 ;
14069   Dali::AngleAxis *result = 0 ;
14070
14071   argp1 = (Dali::Radian *)jarg1;
14072   if (!argp1) {
14073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14074     return 0;
14075   }
14076   arg1 = *argp1;
14077   arg2 = (Dali::Vector3 *)jarg2;
14078   if (!arg2) {
14079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14080     return 0;
14081   }
14082   {
14083     try {
14084       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14085     } catch (std::out_of_range& e) {
14086       {
14087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (std::exception& e) {
14090       {
14091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (Dali::DaliException e) {
14094       {
14095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14096       };
14097     } catch (...) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14100       };
14101     }
14102   }
14103
14104   jresult = (void *)result;
14105   return jresult;
14106 }
14107
14108
14109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14110   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14111   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14112
14113   arg1 = (Dali::AngleAxis *)jarg1;
14114   arg2 = (Dali::Radian *)jarg2;
14115   if (arg1) (arg1)->angle = *arg2;
14116 }
14117
14118
14119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14120   void * jresult ;
14121   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14122   Dali::Radian *result = 0 ;
14123
14124   arg1 = (Dali::AngleAxis *)jarg1;
14125   result = (Dali::Radian *)& ((arg1)->angle);
14126   jresult = (void *)result;
14127   return jresult;
14128 }
14129
14130
14131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14132   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14133   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14134
14135   arg1 = (Dali::AngleAxis *)jarg1;
14136   arg2 = (Dali::Vector3 *)jarg2;
14137   if (arg1) (arg1)->axis = *arg2;
14138 }
14139
14140
14141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14142   void * jresult ;
14143   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14144   Dali::Vector3 *result = 0 ;
14145
14146   arg1 = (Dali::AngleAxis *)jarg1;
14147   result = (Dali::Vector3 *)& ((arg1)->axis);
14148   jresult = (void *)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155
14156   arg1 = (Dali::AngleAxis *)jarg1;
14157   {
14158     try {
14159       delete arg1;
14160     } catch (std::out_of_range& e) {
14161       {
14162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14163       };
14164     } catch (std::exception& e) {
14165       {
14166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14167       };
14168     } catch (Dali::DaliException e) {
14169       {
14170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14171       };
14172     } catch (...) {
14173       {
14174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14175       };
14176     }
14177   }
14178
14179 }
14180
14181
14182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14183   unsigned int jresult ;
14184   Dali::AngleAxis *arg1 = 0 ;
14185   Dali::AngleAxis *arg2 = 0 ;
14186   bool result;
14187
14188   arg1 = (Dali::AngleAxis *)jarg1;
14189   if (!arg1) {
14190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14191     return 0;
14192   }
14193   arg2 = (Dali::AngleAxis *)jarg2;
14194   if (!arg2) {
14195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14196     return 0;
14197   }
14198   {
14199     try {
14200       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14201     } catch (std::out_of_range& e) {
14202       {
14203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14204       };
14205     } catch (std::exception& e) {
14206       {
14207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14208       };
14209     } catch (Dali::DaliException e) {
14210       {
14211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14212       };
14213     } catch (...) {
14214       {
14215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14216       };
14217     }
14218   }
14219
14220   jresult = result;
14221   return jresult;
14222 }
14223
14224
14225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14226   unsigned int jresult ;
14227   unsigned int arg1 ;
14228   unsigned int result;
14229
14230   arg1 = (unsigned int)jarg1;
14231   {
14232     try {
14233       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14234     } catch (std::out_of_range& e) {
14235       {
14236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14237       };
14238     } catch (std::exception& e) {
14239       {
14240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14241       };
14242     } catch (Dali::DaliException e) {
14243       {
14244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14245       };
14246     } catch (...) {
14247       {
14248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14249       };
14250     }
14251   }
14252
14253   jresult = result;
14254   return jresult;
14255 }
14256
14257
14258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14259   unsigned int jresult ;
14260   unsigned int arg1 ;
14261   bool result;
14262
14263   arg1 = (unsigned int)jarg1;
14264   {
14265     try {
14266       result = (bool)Dali::IsPowerOfTwo(arg1);
14267     } catch (std::out_of_range& e) {
14268       {
14269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14270       };
14271     } catch (std::exception& e) {
14272       {
14273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14274       };
14275     } catch (Dali::DaliException e) {
14276       {
14277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14278       };
14279     } catch (...) {
14280       {
14281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14282       };
14283     }
14284   }
14285
14286   jresult = result;
14287   return jresult;
14288 }
14289
14290
14291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14292   float jresult ;
14293   float arg1 ;
14294   float arg2 ;
14295   float result;
14296
14297   arg1 = (float)jarg1;
14298   arg2 = (float)jarg2;
14299   {
14300     try {
14301       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14302     } catch (std::out_of_range& e) {
14303       {
14304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14305       };
14306     } catch (std::exception& e) {
14307       {
14308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14309       };
14310     } catch (Dali::DaliException e) {
14311       {
14312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14313       };
14314     } catch (...) {
14315       {
14316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14317       };
14318     }
14319   }
14320
14321   jresult = result;
14322   return jresult;
14323 }
14324
14325
14326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14327   unsigned int jresult ;
14328   float arg1 ;
14329   bool result;
14330
14331   arg1 = (float)jarg1;
14332   {
14333     try {
14334       result = (bool)Dali::EqualsZero(arg1);
14335     } catch (std::out_of_range& e) {
14336       {
14337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14338       };
14339     } catch (std::exception& e) {
14340       {
14341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14342       };
14343     } catch (Dali::DaliException e) {
14344       {
14345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14346       };
14347     } catch (...) {
14348       {
14349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14350       };
14351     }
14352   }
14353
14354   jresult = result;
14355   return jresult;
14356 }
14357
14358
14359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14360   unsigned int jresult ;
14361   float arg1 ;
14362   float arg2 ;
14363   bool result;
14364
14365   arg1 = (float)jarg1;
14366   arg2 = (float)jarg2;
14367   {
14368     try {
14369       result = (bool)Dali::Equals(arg1,arg2);
14370     } catch (std::out_of_range& e) {
14371       {
14372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14373       };
14374     } catch (std::exception& e) {
14375       {
14376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14377       };
14378     } catch (Dali::DaliException e) {
14379       {
14380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14381       };
14382     } catch (...) {
14383       {
14384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14385       };
14386     }
14387   }
14388
14389   jresult = result;
14390   return jresult;
14391 }
14392
14393
14394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14395   unsigned int jresult ;
14396   float arg1 ;
14397   float arg2 ;
14398   float arg3 ;
14399   bool result;
14400
14401   arg1 = (float)jarg1;
14402   arg2 = (float)jarg2;
14403   arg3 = (float)jarg3;
14404   {
14405     try {
14406       result = (bool)Dali::Equals(arg1,arg2,arg3);
14407     } catch (std::out_of_range& e) {
14408       {
14409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14410       };
14411     } catch (std::exception& e) {
14412       {
14413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14414       };
14415     } catch (Dali::DaliException e) {
14416       {
14417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14418       };
14419     } catch (...) {
14420       {
14421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14422       };
14423     }
14424   }
14425
14426   jresult = result;
14427   return jresult;
14428 }
14429
14430
14431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14432   float jresult ;
14433   float arg1 ;
14434   int arg2 ;
14435   float result;
14436
14437   arg1 = (float)jarg1;
14438   arg2 = (int)jarg2;
14439   {
14440     try {
14441       result = (float)Dali::Round(arg1,arg2);
14442     } catch (std::out_of_range& e) {
14443       {
14444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (std::exception& e) {
14447       {
14448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14449       };
14450     } catch (Dali::DaliException e) {
14451       {
14452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14453       };
14454     } catch (...) {
14455       {
14456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14457       };
14458     }
14459   }
14460
14461   jresult = result;
14462   return jresult;
14463 }
14464
14465
14466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14467   float jresult ;
14468   float arg1 ;
14469   float arg2 ;
14470   float arg3 ;
14471   float result;
14472
14473   arg1 = (float)jarg1;
14474   arg2 = (float)jarg2;
14475   arg3 = (float)jarg3;
14476   {
14477     try {
14478       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14479     } catch (std::out_of_range& e) {
14480       {
14481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (std::exception& e) {
14484       {
14485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14486       };
14487     } catch (Dali::DaliException e) {
14488       {
14489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14490       };
14491     } catch (...) {
14492       {
14493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14494       };
14495     }
14496   }
14497
14498   jresult = result;
14499   return jresult;
14500 }
14501
14502
14503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14504   float jresult ;
14505   float arg1 ;
14506   float arg2 ;
14507   float arg3 ;
14508   float arg4 ;
14509   float result;
14510
14511   arg1 = (float)jarg1;
14512   arg2 = (float)jarg2;
14513   arg3 = (float)jarg3;
14514   arg4 = (float)jarg4;
14515   {
14516     try {
14517       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14518     } catch (std::out_of_range& e) {
14519       {
14520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14521       };
14522     } catch (std::exception& e) {
14523       {
14524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14525       };
14526     } catch (Dali::DaliException e) {
14527       {
14528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14529       };
14530     } catch (...) {
14531       {
14532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14533       };
14534     }
14535   }
14536
14537   jresult = result;
14538   return jresult;
14539 }
14540
14541
14542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14543   int jresult ;
14544   int result;
14545
14546   result = (int)(int)Dali::Property::INVALID_INDEX;
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14553   int jresult ;
14554   int result;
14555
14556   result = (int)(int)Dali::Property::INVALID_KEY;
14557   jresult = result;
14558   return jresult;
14559 }
14560
14561
14562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14563   int jresult ;
14564   int result;
14565
14566   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14567   jresult = result;
14568   return jresult;
14569 }
14570
14571
14572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14573   void * jresult ;
14574   Dali::Handle *arg1 = 0 ;
14575   Dali::Property::Index arg2 ;
14576   Dali::Property *result = 0 ;
14577
14578   arg1 = (Dali::Handle *)jarg1;
14579   if (!arg1) {
14580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14581     return 0;
14582   }
14583   arg2 = (Dali::Property::Index)jarg2;
14584   {
14585     try {
14586       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14587     } catch (std::out_of_range& e) {
14588       {
14589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14590       };
14591     } catch (std::exception& e) {
14592       {
14593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14594       };
14595     } catch (Dali::DaliException e) {
14596       {
14597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14598       };
14599     } catch (...) {
14600       {
14601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14602       };
14603     }
14604   }
14605
14606   jresult = (void *)result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14612   void * jresult ;
14613   Dali::Handle *arg1 = 0 ;
14614   Dali::Property::Index arg2 ;
14615   int arg3 ;
14616   Dali::Property *result = 0 ;
14617
14618   arg1 = (Dali::Handle *)jarg1;
14619   if (!arg1) {
14620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14621     return 0;
14622   }
14623   arg2 = (Dali::Property::Index)jarg2;
14624   arg3 = (int)jarg3;
14625   {
14626     try {
14627       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (Dali::DaliException e) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646
14647   jresult = (void *)result;
14648   return jresult;
14649 }
14650
14651
14652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14653   void * jresult ;
14654   Dali::Handle *arg1 = 0 ;
14655   std::string *arg2 = 0 ;
14656   Dali::Property *result = 0 ;
14657
14658   arg1 = (Dali::Handle *)jarg1;
14659   if (!arg1) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14661     return 0;
14662   }
14663   if (!jarg2) {
14664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14665     return 0;
14666   }
14667   std::string arg2_str(jarg2);
14668   arg2 = &arg2_str;
14669   {
14670     try {
14671       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14672     } catch (std::out_of_range& e) {
14673       {
14674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14675       };
14676     } catch (std::exception& e) {
14677       {
14678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (Dali::DaliException e) {
14681       {
14682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690
14691   jresult = (void *)result;
14692
14693   //argout typemap for const std::string&
14694
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   int arg3 ;
14704   Dali::Property *result = 0 ;
14705
14706   arg1 = (Dali::Handle *)jarg1;
14707   if (!arg1) {
14708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14709     return 0;
14710   }
14711   if (!jarg2) {
14712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14713     return 0;
14714   }
14715   std::string arg2_str(jarg2);
14716   arg2 = &arg2_str;
14717   arg3 = (int)jarg3;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14749   Dali::Property *arg1 = (Dali::Property *) 0 ;
14750
14751   arg1 = (Dali::Property *)jarg1;
14752   {
14753     try {
14754       delete arg1;
14755     } catch (std::out_of_range& e) {
14756       {
14757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14758       };
14759     } catch (std::exception& e) {
14760       {
14761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14762       };
14763     } catch (Dali::DaliException e) {
14764       {
14765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14766       };
14767     } catch (...) {
14768       {
14769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14770       };
14771     }
14772   }
14773
14774 }
14775
14776
14777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14778   Dali::Property *arg1 = (Dali::Property *) 0 ;
14779   Dali::Handle *arg2 = 0 ;
14780
14781   arg1 = (Dali::Property *)jarg1;
14782   arg2 = (Dali::Handle *)jarg2;
14783   if (!arg2) {
14784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14785     return ;
14786   }
14787   if (arg1) (arg1)->object = *arg2;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14792   void * jresult ;
14793   Dali::Property *arg1 = (Dali::Property *) 0 ;
14794   Dali::Handle *result = 0 ;
14795
14796   arg1 = (Dali::Property *)jarg1;
14797   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14798   jresult = (void *)result;
14799   return jresult;
14800 }
14801
14802
14803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14804   Dali::Property *arg1 = (Dali::Property *) 0 ;
14805   Dali::Property::Index arg2 ;
14806
14807   arg1 = (Dali::Property *)jarg1;
14808   arg2 = (Dali::Property::Index)jarg2;
14809   if (arg1) (arg1)->propertyIndex = arg2;
14810 }
14811
14812
14813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14814   int jresult ;
14815   Dali::Property *arg1 = (Dali::Property *) 0 ;
14816   Dali::Property::Index result;
14817
14818   arg1 = (Dali::Property *)jarg1;
14819   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14820   jresult = result;
14821   return jresult;
14822 }
14823
14824
14825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14826   Dali::Property *arg1 = (Dali::Property *) 0 ;
14827   int arg2 ;
14828
14829   arg1 = (Dali::Property *)jarg1;
14830   arg2 = (int)jarg2;
14831   if (arg1) (arg1)->componentIndex = arg2;
14832 }
14833
14834
14835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14836   int jresult ;
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   int result;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   result = (int) ((arg1)->componentIndex);
14842   jresult = result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14848   void * jresult ;
14849   Dali::Property::Array *result = 0 ;
14850
14851   {
14852     try {
14853       result = (Dali::Property::Array *)new Dali::Property::Array();
14854     } catch (std::out_of_range& e) {
14855       {
14856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14857       };
14858     } catch (std::exception& e) {
14859       {
14860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14861       };
14862     } catch (Dali::DaliException e) {
14863       {
14864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14865       };
14866     } catch (...) {
14867       {
14868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14869       };
14870     }
14871   }
14872
14873   jresult = (void *)result;
14874   return jresult;
14875 }
14876
14877
14878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14879   void * jresult ;
14880   Dali::Property::Array *arg1 = 0 ;
14881   Dali::Property::Array *result = 0 ;
14882
14883   arg1 = (Dali::Property::Array *)jarg1;
14884   if (!arg1) {
14885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14886     return 0;
14887   }
14888   {
14889     try {
14890       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14891     } catch (std::out_of_range& e) {
14892       {
14893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14894       };
14895     } catch (std::exception& e) {
14896       {
14897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14898       };
14899     } catch (Dali::DaliException e) {
14900       {
14901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14902       };
14903     } catch (...) {
14904       {
14905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14906       };
14907     }
14908   }
14909
14910   jresult = (void *)result;
14911   return jresult;
14912 }
14913
14914
14915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14916   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14917
14918   arg1 = (Dali::Property::Array *)jarg1;
14919   {
14920     try {
14921       delete arg1;
14922     } catch (std::out_of_range& e) {
14923       {
14924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14925       };
14926     } catch (std::exception& e) {
14927       {
14928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14929       };
14930     } catch (Dali::DaliException e) {
14931       {
14932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14933       };
14934     } catch (...) {
14935       {
14936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14937       };
14938     }
14939   }
14940
14941 }
14942
14943
14944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14945   unsigned long jresult ;
14946   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14947   Dali::Property::Array::SizeType result;
14948
14949   arg1 = (Dali::Property::Array *)jarg1;
14950   {
14951     try {
14952       result = ((Dali::Property::Array const *)arg1)->Size();
14953     } catch (std::out_of_range& e) {
14954       {
14955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (std::exception& e) {
14958       {
14959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14960       };
14961     } catch (Dali::DaliException e) {
14962       {
14963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14964       };
14965     } catch (...) {
14966       {
14967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14968       };
14969     }
14970   }
14971
14972   jresult = (unsigned long)result;
14973   return jresult;
14974 }
14975
14976
14977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14978   unsigned long jresult ;
14979   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14980   Dali::Property::Array::SizeType result;
14981
14982   arg1 = (Dali::Property::Array *)jarg1;
14983   {
14984     try {
14985       result = ((Dali::Property::Array const *)arg1)->Count();
14986     } catch (std::out_of_range& e) {
14987       {
14988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14989       };
14990     } catch (std::exception& e) {
14991       {
14992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14993       };
14994     } catch (Dali::DaliException e) {
14995       {
14996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14997       };
14998     } catch (...) {
14999       {
15000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15001       };
15002     }
15003   }
15004
15005   jresult = (unsigned long)result;
15006   return jresult;
15007 }
15008
15009
15010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15011   unsigned int jresult ;
15012   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15013   bool result;
15014
15015   arg1 = (Dali::Property::Array *)jarg1;
15016   {
15017     try {
15018       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15019     } catch (std::out_of_range& e) {
15020       {
15021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15022       };
15023     } catch (std::exception& e) {
15024       {
15025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15026       };
15027     } catch (Dali::DaliException e) {
15028       {
15029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15030       };
15031     } catch (...) {
15032       {
15033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15034       };
15035     }
15036   }
15037
15038   jresult = result;
15039   return jresult;
15040 }
15041
15042
15043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15044   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15045
15046   arg1 = (Dali::Property::Array *)jarg1;
15047   {
15048     try {
15049       (arg1)->Clear();
15050     } catch (std::out_of_range& e) {
15051       {
15052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15053       };
15054     } catch (std::exception& e) {
15055       {
15056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15057       };
15058     } catch (Dali::DaliException e) {
15059       {
15060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15061       };
15062     } catch (...) {
15063       {
15064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15065       };
15066     }
15067   }
15068
15069 }
15070
15071
15072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15073   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15074   Dali::Property::Array::SizeType arg2 ;
15075
15076   arg1 = (Dali::Property::Array *)jarg1;
15077   arg2 = (Dali::Property::Array::SizeType)jarg2;
15078   {
15079     try {
15080       (arg1)->Reserve(arg2);
15081     } catch (std::out_of_range& e) {
15082       {
15083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15084       };
15085     } catch (std::exception& e) {
15086       {
15087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15088       };
15089     } catch (Dali::DaliException e) {
15090       {
15091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15092       };
15093     } catch (...) {
15094       {
15095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15096       };
15097     }
15098   }
15099
15100 }
15101
15102
15103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15104   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15105   Dali::Property::Array::SizeType arg2 ;
15106
15107   arg1 = (Dali::Property::Array *)jarg1;
15108   arg2 = (Dali::Property::Array::SizeType)jarg2;
15109   {
15110     try {
15111       (arg1)->Resize(arg2);
15112     } catch (std::out_of_range& e) {
15113       {
15114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15115       };
15116     } catch (std::exception& e) {
15117       {
15118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15119       };
15120     } catch (Dali::DaliException e) {
15121       {
15122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15123       };
15124     } catch (...) {
15125       {
15126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15127       };
15128     }
15129   }
15130
15131 }
15132
15133
15134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15135   unsigned long jresult ;
15136   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15137   Dali::Property::Array::SizeType result;
15138
15139   arg1 = (Dali::Property::Array *)jarg1;
15140   {
15141     try {
15142       result = (arg1)->Capacity();
15143     } catch (std::out_of_range& e) {
15144       {
15145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15146       };
15147     } catch (std::exception& e) {
15148       {
15149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15150       };
15151     } catch (Dali::DaliException e) {
15152       {
15153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15154       };
15155     } catch (...) {
15156       {
15157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15158       };
15159     }
15160   }
15161
15162   jresult = (unsigned long)result;
15163   return jresult;
15164 }
15165
15166
15167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15168   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15169   Dali::Property::Value *arg2 = 0 ;
15170
15171   arg1 = (Dali::Property::Array *)jarg1;
15172   arg2 = (Dali::Property::Value *)jarg2;
15173   if (!arg2) {
15174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15175     return ;
15176   }
15177   {
15178     try {
15179       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15180     } catch (std::out_of_range& e) {
15181       {
15182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15183       };
15184     } catch (std::exception& e) {
15185       {
15186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15187       };
15188     } catch (Dali::DaliException e) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15191       };
15192     } catch (...) {
15193       {
15194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15195       };
15196     }
15197   }
15198
15199 }
15200
15201
15202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15203   void * jresult ;
15204   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15205   Dali::Property::Value *arg2 = 0 ;
15206   Dali::Property::Array *result = 0 ;
15207
15208   arg1 = (Dali::Property::Array *)jarg1;
15209   arg2 = (Dali::Property::Value *)jarg2;
15210   if (!arg2) {
15211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15212     return 0;
15213   }
15214   {
15215     try {
15216       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15217     } catch (std::out_of_range& e) {
15218       {
15219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15220       };
15221     } catch (std::exception& e) {
15222       {
15223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15224       };
15225     } catch (Dali::DaliException e) {
15226       {
15227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15228       };
15229     } catch (...) {
15230       {
15231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15232       };
15233     }
15234   }
15235
15236   jresult = (void *)result;
15237   return jresult;
15238 }
15239
15240
15241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15242   void * jresult ;
15243   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15244   Dali::Property::Array::SizeType arg2 ;
15245   Dali::Property::Value *result = 0 ;
15246
15247   arg1 = (Dali::Property::Array *)jarg1;
15248   arg2 = (Dali::Property::Array::SizeType)jarg2;
15249   {
15250     try {
15251       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15252     } catch (std::out_of_range& e) {
15253       {
15254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15255       };
15256     } catch (std::exception& e) {
15257       {
15258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15259       };
15260     } catch (Dali::DaliException e) {
15261       {
15262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15263       };
15264     } catch (...) {
15265       {
15266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15267       };
15268     }
15269   }
15270
15271   jresult = (void *)result;
15272   return jresult;
15273 }
15274
15275
15276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15277   void * jresult ;
15278   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15279   Dali::Property::Array::SizeType arg2 ;
15280   Dali::Property::Value *result = 0 ;
15281
15282   arg1 = (Dali::Property::Array *)jarg1;
15283   arg2 = (Dali::Property::Array::SizeType)jarg2;
15284   {
15285     try {
15286       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15287     } catch (std::out_of_range& e) {
15288       {
15289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15290       };
15291     } catch (std::exception& e) {
15292       {
15293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15294       };
15295     } catch (Dali::DaliException e) {
15296       {
15297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15298       };
15299     } catch (...) {
15300       {
15301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15302       };
15303     }
15304   }
15305
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15312   void * jresult ;
15313   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15314   Dali::Property::Array *arg2 = 0 ;
15315   Dali::Property::Array *result = 0 ;
15316
15317   arg1 = (Dali::Property::Array *)jarg1;
15318   arg2 = (Dali::Property::Array *)jarg2;
15319   if (!arg2) {
15320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15321     return 0;
15322   }
15323   {
15324     try {
15325       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (Dali::DaliException e) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15337       };
15338     } catch (...) {
15339       {
15340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15341       };
15342     }
15343   }
15344
15345   jresult = (void *)result;
15346   return jresult;
15347 }
15348
15349
15350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15351   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15352   enum Dali::Property::Key::Type arg2 ;
15353
15354   arg1 = (Dali::Property::Key *)jarg1;
15355   arg2 = (enum Dali::Property::Key::Type)jarg2;
15356   if (arg1) (arg1)->type = arg2;
15357 }
15358
15359
15360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15361   int jresult ;
15362   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15363   enum Dali::Property::Key::Type result;
15364
15365   arg1 = (Dali::Property::Key *)jarg1;
15366   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15367   jresult = (int)result;
15368   return jresult;
15369 }
15370
15371
15372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15373   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15374   Dali::Property::Index arg2 ;
15375
15376   arg1 = (Dali::Property::Key *)jarg1;
15377   arg2 = (Dali::Property::Index)jarg2;
15378   if (arg1) (arg1)->indexKey = arg2;
15379 }
15380
15381
15382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15383   int jresult ;
15384   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15385   Dali::Property::Index result;
15386
15387   arg1 = (Dali::Property::Key *)jarg1;
15388   result = (Dali::Property::Index) ((arg1)->indexKey);
15389   jresult = result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   std::string *arg2 = 0 ;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   if (!jarg2) {
15400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15401     return ;
15402   }
15403   std::string arg2_str(jarg2);
15404   arg2 = &arg2_str;
15405   if (arg1) (arg1)->stringKey = *arg2;
15406
15407   //argout typemap for const std::string&
15408
15409 }
15410
15411
15412 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15413   char * jresult ;
15414   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15415   std::string *result = 0 ;
15416
15417   arg1 = (Dali::Property::Key *)jarg1;
15418   result = (std::string *) & ((arg1)->stringKey);
15419   jresult = SWIG_csharp_string_callback(result->c_str());
15420   return jresult;
15421 }
15422
15423
15424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15425   void * jresult ;
15426   std::string *arg1 = 0 ;
15427   Dali::Property::Key *result = 0 ;
15428
15429   if (!jarg1) {
15430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15431     return 0;
15432   }
15433   std::string arg1_str(jarg1);
15434   arg1 = &arg1_str;
15435   {
15436     try {
15437       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (Dali::DaliException e) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15449       };
15450     } catch (...) {
15451       {
15452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15453       };
15454     }
15455   }
15456
15457   jresult = (void *)result;
15458
15459   //argout typemap for const std::string&
15460
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15466   void * jresult ;
15467   Dali::Property::Index arg1 ;
15468   Dali::Property::Key *result = 0 ;
15469
15470   arg1 = (Dali::Property::Index)jarg1;
15471   {
15472     try {
15473       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15474     } catch (std::out_of_range& e) {
15475       {
15476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (std::exception& e) {
15479       {
15480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15481       };
15482     } catch (Dali::DaliException e) {
15483       {
15484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15485       };
15486     } catch (...) {
15487       {
15488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15489       };
15490     }
15491   }
15492
15493   jresult = (void *)result;
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15499   unsigned int jresult ;
15500   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15501   std::string *arg2 = 0 ;
15502   bool result;
15503
15504   arg1 = (Dali::Property::Key *)jarg1;
15505   if (!jarg2) {
15506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15507     return 0;
15508   }
15509   std::string arg2_str(jarg2);
15510   arg2 = &arg2_str;
15511   {
15512     try {
15513       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15514     } catch (std::out_of_range& e) {
15515       {
15516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15517       };
15518     } catch (std::exception& e) {
15519       {
15520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15521       };
15522     } catch (Dali::DaliException e) {
15523       {
15524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15525       };
15526     } catch (...) {
15527       {
15528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15529       };
15530     }
15531   }
15532
15533   jresult = result;
15534
15535   //argout typemap for const std::string&
15536
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15542   unsigned int jresult ;
15543   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15544   Dali::Property::Index arg2 ;
15545   bool result;
15546
15547   arg1 = (Dali::Property::Key *)jarg1;
15548   arg2 = (Dali::Property::Index)jarg2;
15549   {
15550     try {
15551       result = (bool)(arg1)->operator ==(arg2);
15552     } catch (std::out_of_range& e) {
15553       {
15554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15555       };
15556     } catch (std::exception& e) {
15557       {
15558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15559       };
15560     } catch (Dali::DaliException e) {
15561       {
15562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15563       };
15564     } catch (...) {
15565       {
15566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15567       };
15568     }
15569   }
15570
15571   jresult = result;
15572   return jresult;
15573 }
15574
15575
15576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15577   unsigned int jresult ;
15578   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15579   Dali::Property::Key *arg2 = 0 ;
15580   bool result;
15581
15582   arg1 = (Dali::Property::Key *)jarg1;
15583   arg2 = (Dali::Property::Key *)jarg2;
15584   if (!arg2) {
15585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15586     return 0;
15587   }
15588   {
15589     try {
15590       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15591     } catch (std::out_of_range& e) {
15592       {
15593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15594       };
15595     } catch (std::exception& e) {
15596       {
15597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15598       };
15599     } catch (Dali::DaliException e) {
15600       {
15601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15602       };
15603     } catch (...) {
15604       {
15605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15606       };
15607     }
15608   }
15609
15610   jresult = result;
15611   return jresult;
15612 }
15613
15614
15615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15616   unsigned int jresult ;
15617   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15618   std::string *arg2 = 0 ;
15619   bool result;
15620
15621   arg1 = (Dali::Property::Key *)jarg1;
15622   if (!jarg2) {
15623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15624     return 0;
15625   }
15626   std::string arg2_str(jarg2);
15627   arg2 = &arg2_str;
15628   {
15629     try {
15630       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15631     } catch (std::out_of_range& e) {
15632       {
15633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15634       };
15635     } catch (std::exception& e) {
15636       {
15637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15638       };
15639     } catch (Dali::DaliException e) {
15640       {
15641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15642       };
15643     } catch (...) {
15644       {
15645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15646       };
15647     }
15648   }
15649
15650   jresult = result;
15651
15652   //argout typemap for const std::string&
15653
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15661   Dali::Property::Index arg2 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Key *)jarg1;
15665   arg2 = (Dali::Property::Index)jarg2;
15666   {
15667     try {
15668       result = (bool)(arg1)->operator !=(arg2);
15669     } catch (std::out_of_range& e) {
15670       {
15671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15672       };
15673     } catch (std::exception& e) {
15674       {
15675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15676       };
15677     } catch (Dali::DaliException e) {
15678       {
15679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15680       };
15681     } catch (...) {
15682       {
15683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15684       };
15685     }
15686   }
15687
15688   jresult = result;
15689   return jresult;
15690 }
15691
15692
15693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15694   unsigned int jresult ;
15695   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15696   Dali::Property::Key *arg2 = 0 ;
15697   bool result;
15698
15699   arg1 = (Dali::Property::Key *)jarg1;
15700   arg2 = (Dali::Property::Key *)jarg2;
15701   if (!arg2) {
15702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15703     return 0;
15704   }
15705   {
15706     try {
15707       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15708     } catch (std::out_of_range& e) {
15709       {
15710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15711       };
15712     } catch (std::exception& e) {
15713       {
15714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (Dali::DaliException e) {
15717       {
15718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15719       };
15720     } catch (...) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15723       };
15724     }
15725   }
15726
15727   jresult = result;
15728   return jresult;
15729 }
15730
15731
15732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15733   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15734
15735   arg1 = (Dali::Property::Key *)jarg1;
15736   {
15737     try {
15738       delete arg1;
15739     } catch (std::out_of_range& e) {
15740       {
15741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15742       };
15743     } catch (std::exception& e) {
15744       {
15745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15746       };
15747     } catch (Dali::DaliException e) {
15748       {
15749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15750       };
15751     } catch (...) {
15752       {
15753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15754       };
15755     }
15756   }
15757
15758 }
15759
15760
15761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15762   void * jresult ;
15763   Dali::Property::Map *result = 0 ;
15764
15765   {
15766     try {
15767       result = (Dali::Property::Map *)new Dali::Property::Map();
15768     } catch (std::out_of_range& e) {
15769       {
15770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15771       };
15772     } catch (std::exception& e) {
15773       {
15774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15775       };
15776     } catch (Dali::DaliException e) {
15777       {
15778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15779       };
15780     } catch (...) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15783       };
15784     }
15785   }
15786
15787   jresult = (void *)result;
15788   return jresult;
15789 }
15790
15791
15792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15793   void * jresult ;
15794   Dali::Property::Map *arg1 = 0 ;
15795   Dali::Property::Map *result = 0 ;
15796
15797   arg1 = (Dali::Property::Map *)jarg1;
15798   if (!arg1) {
15799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15800     return 0;
15801   }
15802   {
15803     try {
15804       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15805     } catch (std::out_of_range& e) {
15806       {
15807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15808       };
15809     } catch (std::exception& e) {
15810       {
15811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (Dali::DaliException e) {
15814       {
15815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15816       };
15817     } catch (...) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15820       };
15821     }
15822   }
15823
15824   jresult = (void *)result;
15825   return jresult;
15826 }
15827
15828
15829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15830   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15831
15832   arg1 = (Dali::Property::Map *)jarg1;
15833   {
15834     try {
15835       delete arg1;
15836     } catch (std::out_of_range& e) {
15837       {
15838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15839       };
15840     } catch (std::exception& e) {
15841       {
15842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15843       };
15844     } catch (Dali::DaliException e) {
15845       {
15846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15847       };
15848     } catch (...) {
15849       {
15850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15851       };
15852     }
15853   }
15854
15855 }
15856
15857
15858 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15859   unsigned long jresult ;
15860   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15861   Dali::Property::Map::SizeType result;
15862
15863   arg1 = (Dali::Property::Map *)jarg1;
15864   {
15865     try {
15866       result = ((Dali::Property::Map const *)arg1)->Count();
15867     } catch (std::out_of_range& e) {
15868       {
15869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15870       };
15871     } catch (std::exception& e) {
15872       {
15873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15874       };
15875     } catch (Dali::DaliException e) {
15876       {
15877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15878       };
15879     } catch (...) {
15880       {
15881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15882       };
15883     }
15884   }
15885
15886   jresult = (unsigned long)result;
15887   return jresult;
15888 }
15889
15890
15891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15892   unsigned int jresult ;
15893   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15894   bool result;
15895
15896   arg1 = (Dali::Property::Map *)jarg1;
15897   {
15898     try {
15899       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15900     } catch (std::out_of_range& e) {
15901       {
15902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15903       };
15904     } catch (std::exception& e) {
15905       {
15906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15907       };
15908     } catch (Dali::DaliException e) {
15909       {
15910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15911       };
15912     } catch (...) {
15913       {
15914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15915       };
15916     }
15917   }
15918
15919   jresult = result;
15920   return jresult;
15921 }
15922
15923
15924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15925   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15926   char *arg2 = (char *) 0 ;
15927   Dali::Property::Value *arg3 = 0 ;
15928
15929   arg1 = (Dali::Property::Map *)jarg1;
15930   arg2 = (char *)jarg2;
15931   arg3 = (Dali::Property::Value *)jarg3;
15932   if (!arg3) {
15933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15934     return ;
15935   }
15936   {
15937     try {
15938       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15939     } catch (std::out_of_range& e) {
15940       {
15941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15942       };
15943     } catch (std::exception& e) {
15944       {
15945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15946       };
15947     } catch (Dali::DaliException e) {
15948       {
15949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15950       };
15951     } catch (...) {
15952       {
15953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15954       };
15955     }
15956   }
15957
15958 }
15959
15960
15961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15962   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15963   Dali::Property::Index arg2 ;
15964   Dali::Property::Value *arg3 = 0 ;
15965
15966   arg1 = (Dali::Property::Map *)jarg1;
15967   arg2 = (Dali::Property::Index)jarg2;
15968   arg3 = (Dali::Property::Value *)jarg3;
15969   if (!arg3) {
15970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15971     return ;
15972   }
15973   {
15974     try {
15975       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15976     } catch (std::out_of_range& e) {
15977       {
15978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15979       };
15980     } catch (std::exception& e) {
15981       {
15982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15983       };
15984     } catch (Dali::DaliException e) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15987       };
15988     } catch (...) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15991       };
15992     }
15993   }
15994
15995 }
15996
15997
15998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15999   void * jresult ;
16000   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16001   char *arg2 = (char *) 0 ;
16002   Dali::Property::Value *arg3 = 0 ;
16003   Dali::Property::Map *result = 0 ;
16004
16005   arg1 = (Dali::Property::Map *)jarg1;
16006   arg2 = (char *)jarg2;
16007   arg3 = (Dali::Property::Value *)jarg3;
16008   if (!arg3) {
16009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16010     return 0;
16011   }
16012   {
16013     try {
16014       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16015     } catch (std::out_of_range& e) {
16016       {
16017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16018       };
16019     } catch (std::exception& e) {
16020       {
16021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16022       };
16023     } catch (Dali::DaliException e) {
16024       {
16025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16026       };
16027     } catch (...) {
16028       {
16029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16030       };
16031     }
16032   }
16033
16034   jresult = (void *)result;
16035   return jresult;
16036 }
16037
16038
16039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16040   void * jresult ;
16041   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16042   Dali::Property::Index arg2 ;
16043   Dali::Property::Value *arg3 = 0 ;
16044   Dali::Property::Map *result = 0 ;
16045
16046   arg1 = (Dali::Property::Map *)jarg1;
16047   arg2 = (Dali::Property::Index)jarg2;
16048   arg3 = (Dali::Property::Value *)jarg3;
16049   if (!arg3) {
16050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16051     return 0;
16052   }
16053   {
16054     try {
16055       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (Dali::DaliException e) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16067       };
16068     } catch (...) {
16069       {
16070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16071       };
16072     }
16073   }
16074
16075   jresult = (void *)result;
16076   return jresult;
16077 }
16078
16079
16080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16081   void * jresult ;
16082   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16083   Dali::Property::Map::SizeType arg2 ;
16084   Dali::Property::Value *result = 0 ;
16085
16086   arg1 = (Dali::Property::Map *)jarg1;
16087   arg2 = (Dali::Property::Map::SizeType)jarg2;
16088   {
16089     try {
16090       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16098       };
16099     } catch (Dali::DaliException e) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16102       };
16103     } catch (...) {
16104       {
16105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16106       };
16107     }
16108   }
16109
16110   jresult = (void *)result;
16111   return jresult;
16112 }
16113
16114
16115 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16116   char * jresult ;
16117   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16118   Dali::Property::Map::SizeType arg2 ;
16119   std::string *result = 0 ;
16120
16121   arg1 = (Dali::Property::Map *)jarg1;
16122   arg2 = (Dali::Property::Map::SizeType)jarg2;
16123   {
16124     try {
16125       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16126     } catch (std::out_of_range& e) {
16127       {
16128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16129       };
16130     } catch (std::exception& e) {
16131       {
16132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16133       };
16134     } catch (Dali::DaliException e) {
16135       {
16136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16137       };
16138     } catch (...) {
16139       {
16140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16141       };
16142     }
16143   }
16144
16145   jresult = SWIG_csharp_string_callback(result->c_str());
16146   return jresult;
16147 }
16148
16149
16150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16151   void * jresult ;
16152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16153   Dali::Property::Map::SizeType arg2 ;
16154   SwigValueWrapper< Dali::Property::Key > result;
16155
16156   arg1 = (Dali::Property::Map *)jarg1;
16157   arg2 = (Dali::Property::Map::SizeType)jarg2;
16158   {
16159     try {
16160       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16161     } catch (std::out_of_range& e) {
16162       {
16163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16164       };
16165     } catch (std::exception& e) {
16166       {
16167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16168       };
16169     } catch (Dali::DaliException e) {
16170       {
16171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16172       };
16173     } catch (...) {
16174       {
16175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16176       };
16177     }
16178   }
16179
16180   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16181   return jresult;
16182 }
16183
16184
16185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16186   void * jresult ;
16187   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16188   Dali::Property::Map::SizeType arg2 ;
16189   StringValuePair *result = 0 ;
16190
16191   arg1 = (Dali::Property::Map *)jarg1;
16192   arg2 = (Dali::Property::Map::SizeType)jarg2;
16193   {
16194     try {
16195       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16196     } catch (std::out_of_range& e) {
16197       {
16198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16199       };
16200     } catch (std::exception& e) {
16201       {
16202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16203       };
16204     } catch (Dali::DaliException e) {
16205       {
16206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16207       };
16208     } catch (...) {
16209       {
16210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16211       };
16212     }
16213   }
16214
16215   jresult = (void *)result;
16216   return jresult;
16217 }
16218
16219
16220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16221   void * jresult ;
16222   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16223   char *arg2 = (char *) 0 ;
16224   Dali::Property::Value *result = 0 ;
16225
16226   arg1 = (Dali::Property::Map *)jarg1;
16227   arg2 = (char *)jarg2;
16228   {
16229     try {
16230       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16231     } catch (std::out_of_range& e) {
16232       {
16233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16234       };
16235     } catch (std::exception& e) {
16236       {
16237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16238       };
16239     } catch (Dali::DaliException e) {
16240       {
16241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16242       };
16243     } catch (...) {
16244       {
16245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16246       };
16247     }
16248   }
16249
16250   jresult = (void *)result;
16251   return jresult;
16252 }
16253
16254
16255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16256   void * jresult ;
16257   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16258   Dali::Property::Index arg2 ;
16259   Dali::Property::Value *result = 0 ;
16260
16261   arg1 = (Dali::Property::Map *)jarg1;
16262   arg2 = (Dali::Property::Index)jarg2;
16263   {
16264     try {
16265       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16266     } catch (std::out_of_range& e) {
16267       {
16268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16269       };
16270     } catch (std::exception& e) {
16271       {
16272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16273       };
16274     } catch (Dali::DaliException e) {
16275       {
16276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16277       };
16278     } catch (...) {
16279       {
16280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16281       };
16282     }
16283   }
16284
16285   jresult = (void *)result;
16286   return jresult;
16287 }
16288
16289
16290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16291   void * jresult ;
16292   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16293   Dali::Property::Index arg2 ;
16294   std::string *arg3 = 0 ;
16295   Dali::Property::Value *result = 0 ;
16296
16297   arg1 = (Dali::Property::Map *)jarg1;
16298   arg2 = (Dali::Property::Index)jarg2;
16299   if (!jarg3) {
16300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16301     return 0;
16302   }
16303   std::string arg3_str(jarg3);
16304   arg3 = &arg3_str;
16305   {
16306     try {
16307       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16308     } catch (std::out_of_range& e) {
16309       {
16310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16311       };
16312     } catch (std::exception& e) {
16313       {
16314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (Dali::DaliException e) {
16317       {
16318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16319       };
16320     } catch (...) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16323       };
16324     }
16325   }
16326
16327   jresult = (void *)result;
16328
16329   //argout typemap for const std::string&
16330
16331   return jresult;
16332 }
16333
16334
16335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16336   void * jresult ;
16337   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16338   std::string *arg2 = 0 ;
16339   Dali::Property::Type arg3 ;
16340   Dali::Property::Value *result = 0 ;
16341
16342   arg1 = (Dali::Property::Map *)jarg1;
16343   if (!jarg2) {
16344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16345     return 0;
16346   }
16347   std::string arg2_str(jarg2);
16348   arg2 = &arg2_str;
16349   arg3 = (Dali::Property::Type)jarg3;
16350   {
16351     try {
16352       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16353     } catch (std::out_of_range& e) {
16354       {
16355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16356       };
16357     } catch (std::exception& e) {
16358       {
16359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (Dali::DaliException e) {
16362       {
16363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16364       };
16365     } catch (...) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16368       };
16369     }
16370   }
16371
16372   jresult = (void *)result;
16373
16374   //argout typemap for const std::string&
16375
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16381   void * jresult ;
16382   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16383   Dali::Property::Index arg2 ;
16384   Dali::Property::Type arg3 ;
16385   Dali::Property::Value *result = 0 ;
16386
16387   arg1 = (Dali::Property::Map *)jarg1;
16388   arg2 = (Dali::Property::Index)jarg2;
16389   arg3 = (Dali::Property::Type)jarg3;
16390   {
16391     try {
16392       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16393     } catch (std::out_of_range& e) {
16394       {
16395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (std::exception& e) {
16398       {
16399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (Dali::DaliException e) {
16402       {
16403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16404       };
16405     } catch (...) {
16406       {
16407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16408       };
16409     }
16410   }
16411
16412   jresult = (void *)result;
16413   return jresult;
16414 }
16415
16416
16417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16419
16420   arg1 = (Dali::Property::Map *)jarg1;
16421   {
16422     try {
16423       (arg1)->Clear();
16424     } catch (std::out_of_range& e) {
16425       {
16426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16427       };
16428     } catch (std::exception& e) {
16429       {
16430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16431       };
16432     } catch (Dali::DaliException e) {
16433       {
16434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16435       };
16436     } catch (...) {
16437       {
16438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16439       };
16440     }
16441   }
16442
16443 }
16444
16445
16446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16447   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16448   Dali::Property::Map *arg2 = 0 ;
16449
16450   arg1 = (Dali::Property::Map *)jarg1;
16451   arg2 = (Dali::Property::Map *)jarg2;
16452   if (!arg2) {
16453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16454     return ;
16455   }
16456   {
16457     try {
16458       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16459     } catch (std::out_of_range& e) {
16460       {
16461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16462       };
16463     } catch (std::exception& e) {
16464       {
16465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16466       };
16467     } catch (Dali::DaliException e) {
16468       {
16469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16470       };
16471     } catch (...) {
16472       {
16473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16474       };
16475     }
16476   }
16477
16478 }
16479
16480
16481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16482   void * jresult ;
16483   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16484   std::string *arg2 = 0 ;
16485   Dali::Property::Value *result = 0 ;
16486
16487   arg1 = (Dali::Property::Map *)jarg1;
16488   if (!jarg2) {
16489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16490     return 0;
16491   }
16492   std::string arg2_str(jarg2);
16493   arg2 = &arg2_str;
16494   {
16495     try {
16496       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16497     } catch (std::out_of_range& e) {
16498       {
16499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16500       };
16501     } catch (std::exception& e) {
16502       {
16503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16504       };
16505     } catch (Dali::DaliException e) {
16506       {
16507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16508       };
16509     } catch (...) {
16510       {
16511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16512       };
16513     }
16514   }
16515
16516   jresult = (void *)result;
16517
16518   //argout typemap for const std::string&
16519
16520   return jresult;
16521 }
16522
16523
16524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16525   void * jresult ;
16526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16527   Dali::Property::Index arg2 ;
16528   Dali::Property::Value *result = 0 ;
16529
16530   arg1 = (Dali::Property::Map *)jarg1;
16531   arg2 = (Dali::Property::Index)jarg2;
16532   {
16533     try {
16534       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16535     } catch (std::out_of_range& e) {
16536       {
16537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16538       };
16539     } catch (std::exception& e) {
16540       {
16541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16542       };
16543     } catch (Dali::DaliException e) {
16544       {
16545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16546       };
16547     } catch (...) {
16548       {
16549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16550       };
16551     }
16552   }
16553
16554   jresult = (void *)result;
16555   return jresult;
16556 }
16557
16558
16559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16560   void * jresult ;
16561   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16562   Dali::Property::Map *arg2 = 0 ;
16563   Dali::Property::Map *result = 0 ;
16564
16565   arg1 = (Dali::Property::Map *)jarg1;
16566   arg2 = (Dali::Property::Map *)jarg2;
16567   if (!arg2) {
16568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16569     return 0;
16570   }
16571   {
16572     try {
16573       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16574     } catch (std::out_of_range& e) {
16575       {
16576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16577       };
16578     } catch (std::exception& e) {
16579       {
16580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (Dali::DaliException e) {
16583       {
16584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16585       };
16586     } catch (...) {
16587       {
16588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16589       };
16590     }
16591   }
16592
16593   jresult = (void *)result;
16594   return jresult;
16595 }
16596
16597
16598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16599
16600   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16601
16602   if (!jarg2) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16604     return;
16605   }
16606   std::string arg2_str(jarg2);
16607   std::string* arg2 = &arg2_str;
16608
16609   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16610
16611   {
16612     try {
16613       arg1->operator[]((std::string const &)*arg2) = *arg3;
16614     } catch (std::out_of_range& e) {
16615       {
16616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16617       };
16618     } catch (std::exception& e) {
16619       {
16620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16621       };
16622     } catch (Dali::DaliException e) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16625       };
16626     } catch (...) {
16627       {
16628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16629       };
16630     }
16631   }
16632 }
16633
16634
16635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16636
16637   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16638   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16639   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16640
16641   {
16642     try {
16643       arg1->operator[](arg2) = *arg3;
16644     } catch (std::out_of_range& e) {
16645       {
16646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16647       };
16648     } catch (std::exception& e) {
16649       {
16650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16651       };
16652     } catch (Dali::DaliException e) {
16653       {
16654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16655       };
16656     } catch (...) {
16657       {
16658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16659       };
16660     }
16661   }
16662 }
16663
16664
16665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16666   void * jresult ;
16667   Dali::Property::Value *result = 0 ;
16668
16669   {
16670     try {
16671       result = (Dali::Property::Value *)new Dali::Property::Value();
16672     } catch (std::out_of_range& e) {
16673       {
16674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16675       };
16676     } catch (std::exception& e) {
16677       {
16678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16679       };
16680     } catch (Dali::DaliException e) {
16681       {
16682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16683       };
16684     } catch (...) {
16685       {
16686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16687       };
16688     }
16689   }
16690
16691   jresult = (void *)result;
16692   return jresult;
16693 }
16694
16695
16696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16697   void * jresult ;
16698   bool arg1 ;
16699   Dali::Property::Value *result = 0 ;
16700
16701   arg1 = jarg1 ? true : false;
16702   {
16703     try {
16704       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16705     } catch (std::out_of_range& e) {
16706       {
16707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16708       };
16709     } catch (std::exception& e) {
16710       {
16711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16712       };
16713     } catch (Dali::DaliException e) {
16714       {
16715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16716       };
16717     } catch (...) {
16718       {
16719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16720       };
16721     }
16722   }
16723
16724   jresult = (void *)result;
16725   return jresult;
16726 }
16727
16728
16729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16730   void * jresult ;
16731   int arg1 ;
16732   Dali::Property::Value *result = 0 ;
16733
16734   arg1 = (int)jarg1;
16735   {
16736     try {
16737       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16738     } catch (std::out_of_range& e) {
16739       {
16740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16741       };
16742     } catch (std::exception& e) {
16743       {
16744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16745       };
16746     } catch (Dali::DaliException e) {
16747       {
16748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16749       };
16750     } catch (...) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16753       };
16754     }
16755   }
16756
16757   jresult = (void *)result;
16758   return jresult;
16759 }
16760
16761
16762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16763   void * jresult ;
16764   float arg1 ;
16765   Dali::Property::Value *result = 0 ;
16766
16767   arg1 = (float)jarg1;
16768   {
16769     try {
16770       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16771     } catch (std::out_of_range& e) {
16772       {
16773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16774       };
16775     } catch (std::exception& e) {
16776       {
16777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16778       };
16779     } catch (Dali::DaliException e) {
16780       {
16781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16782       };
16783     } catch (...) {
16784       {
16785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16786       };
16787     }
16788   }
16789
16790   jresult = (void *)result;
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16796   void * jresult ;
16797   Dali::Vector2 *arg1 = 0 ;
16798   Dali::Property::Value *result = 0 ;
16799
16800   arg1 = (Dali::Vector2 *)jarg1;
16801   if (!arg1) {
16802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16803     return 0;
16804   }
16805   {
16806     try {
16807       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16808     } catch (std::out_of_range& e) {
16809       {
16810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16811       };
16812     } catch (std::exception& e) {
16813       {
16814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16815       };
16816     } catch (Dali::DaliException e) {
16817       {
16818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16823       };
16824     }
16825   }
16826
16827   jresult = (void *)result;
16828   return jresult;
16829 }
16830
16831
16832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16833   void * jresult ;
16834   Dali::Vector3 *arg1 = 0 ;
16835   Dali::Property::Value *result = 0 ;
16836
16837   arg1 = (Dali::Vector3 *)jarg1;
16838   if (!arg1) {
16839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16840     return 0;
16841   }
16842   {
16843     try {
16844       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16845     } catch (std::out_of_range& e) {
16846       {
16847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16848       };
16849     } catch (std::exception& e) {
16850       {
16851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16852       };
16853     } catch (Dali::DaliException e) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16856       };
16857     } catch (...) {
16858       {
16859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16860       };
16861     }
16862   }
16863
16864   jresult = (void *)result;
16865   return jresult;
16866 }
16867
16868
16869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16870   void * jresult ;
16871   Dali::Vector4 *arg1 = 0 ;
16872   Dali::Property::Value *result = 0 ;
16873
16874   arg1 = (Dali::Vector4 *)jarg1;
16875   if (!arg1) {
16876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16877     return 0;
16878   }
16879   {
16880     try {
16881       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16882     } catch (std::out_of_range& e) {
16883       {
16884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16885       };
16886     } catch (std::exception& e) {
16887       {
16888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16889       };
16890     } catch (Dali::DaliException e) {
16891       {
16892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16893       };
16894     } catch (...) {
16895       {
16896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16897       };
16898     }
16899   }
16900
16901   jresult = (void *)result;
16902   return jresult;
16903 }
16904
16905
16906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16907   void * jresult ;
16908   Dali::Matrix3 *arg1 = 0 ;
16909   Dali::Property::Value *result = 0 ;
16910
16911   arg1 = (Dali::Matrix3 *)jarg1;
16912   if (!arg1) {
16913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16914     return 0;
16915   }
16916   {
16917     try {
16918       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16919     } catch (std::out_of_range& e) {
16920       {
16921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16922       };
16923     } catch (std::exception& e) {
16924       {
16925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16926       };
16927     } catch (Dali::DaliException e) {
16928       {
16929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16930       };
16931     } catch (...) {
16932       {
16933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16934       };
16935     }
16936   }
16937
16938   jresult = (void *)result;
16939   return jresult;
16940 }
16941
16942
16943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16944   void * jresult ;
16945   Dali::Matrix *arg1 = 0 ;
16946   Dali::Property::Value *result = 0 ;
16947
16948   arg1 = (Dali::Matrix *)jarg1;
16949   if (!arg1) {
16950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16951     return 0;
16952   }
16953   {
16954     try {
16955       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16956     } catch (std::out_of_range& e) {
16957       {
16958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (std::exception& e) {
16961       {
16962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16963       };
16964     } catch (Dali::DaliException e) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16967       };
16968     } catch (...) {
16969       {
16970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16971       };
16972     }
16973   }
16974
16975   jresult = (void *)result;
16976   return jresult;
16977 }
16978
16979
16980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16981   void * jresult ;
16982   Dali::Rect< int > *arg1 = 0 ;
16983   Dali::Property::Value *result = 0 ;
16984
16985   arg1 = (Dali::Rect< int > *)jarg1;
16986   if (!arg1) {
16987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16988     return 0;
16989   }
16990   {
16991     try {
16992       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16993     } catch (std::out_of_range& e) {
16994       {
16995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (std::exception& e) {
16998       {
16999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17000       };
17001     } catch (Dali::DaliException e) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17004       };
17005     } catch (...) {
17006       {
17007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17008       };
17009     }
17010   }
17011
17012   jresult = (void *)result;
17013   return jresult;
17014 }
17015
17016
17017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17018   void * jresult ;
17019   Dali::AngleAxis *arg1 = 0 ;
17020   Dali::Property::Value *result = 0 ;
17021
17022   arg1 = (Dali::AngleAxis *)jarg1;
17023   if (!arg1) {
17024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17025     return 0;
17026   }
17027   {
17028     try {
17029       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17030     } catch (std::out_of_range& e) {
17031       {
17032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17033       };
17034     } catch (std::exception& e) {
17035       {
17036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17037       };
17038     } catch (Dali::DaliException e) {
17039       {
17040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17041       };
17042     } catch (...) {
17043       {
17044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17045       };
17046     }
17047   }
17048
17049   jresult = (void *)result;
17050   return jresult;
17051 }
17052
17053
17054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17055   void * jresult ;
17056   Dali::Quaternion *arg1 = 0 ;
17057   Dali::Property::Value *result = 0 ;
17058
17059   arg1 = (Dali::Quaternion *)jarg1;
17060   if (!arg1) {
17061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17062     return 0;
17063   }
17064   {
17065     try {
17066       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (Dali::DaliException e) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17078       };
17079     } catch (...) {
17080       {
17081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17082       };
17083     }
17084   }
17085
17086   jresult = (void *)result;
17087   return jresult;
17088 }
17089
17090
17091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17092   void * jresult ;
17093   std::string *arg1 = 0 ;
17094   Dali::Property::Value *result = 0 ;
17095
17096   if (!jarg1) {
17097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17098     return 0;
17099   }
17100   std::string arg1_str(jarg1);
17101   arg1 = &arg1_str;
17102   {
17103     try {
17104       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17105     } catch (std::out_of_range& e) {
17106       {
17107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17108       };
17109     } catch (std::exception& e) {
17110       {
17111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17112       };
17113     } catch (Dali::DaliException e) {
17114       {
17115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17116       };
17117     } catch (...) {
17118       {
17119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17120       };
17121     }
17122   }
17123
17124   jresult = (void *)result;
17125
17126   //argout typemap for const std::string&
17127
17128   return jresult;
17129 }
17130
17131
17132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17133   void * jresult ;
17134   Dali::Property::Array *arg1 = 0 ;
17135   Dali::Property::Value *result = 0 ;
17136
17137   arg1 = (Dali::Property::Array *)jarg1;
17138   if (!arg1) {
17139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17140     return 0;
17141   }
17142   {
17143     try {
17144       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17145     } catch (std::out_of_range& e) {
17146       {
17147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (std::exception& e) {
17150       {
17151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (Dali::DaliException e) {
17154       {
17155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17156       };
17157     } catch (...) {
17158       {
17159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17160       };
17161     }
17162   }
17163
17164   jresult = (void *)result;
17165   return jresult;
17166 }
17167
17168
17169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17170   void * jresult ;
17171   Dali::Property::Map *arg1 = 0 ;
17172   Dali::Property::Value *result = 0 ;
17173
17174   arg1 = (Dali::Property::Map *)jarg1;
17175   if (!arg1) {
17176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17177     return 0;
17178   }
17179   {
17180     try {
17181       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17182     } catch (std::out_of_range& e) {
17183       {
17184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (std::exception& e) {
17187       {
17188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (Dali::DaliException e) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200
17201   jresult = (void *)result;
17202   return jresult;
17203 }
17204
17205
17206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17207   void * jresult ;
17208   Extents *arg1 = 0 ;
17209   Dali::Property::Value *result = 0 ;
17210
17211   arg1 = (Extents *)jarg1;
17212   if (!arg1) {
17213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17214     return 0;
17215   }
17216   {
17217     try {
17218       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17219     } catch (std::out_of_range& e) {
17220       {
17221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (std::exception& e) {
17224       {
17225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17226       };
17227     } catch (...) {
17228       {
17229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17230       };
17231     }
17232   }
17233   jresult = (void *)result;
17234   return jresult;
17235 }
17236
17237
17238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17239   void * jresult ;
17240   Dali::Property::Type arg1 ;
17241   Dali::Property::Value *result = 0 ;
17242
17243   arg1 = (Dali::Property::Type)jarg1;
17244   {
17245     try {
17246       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17247     } catch (std::out_of_range& e) {
17248       {
17249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17250       };
17251     } catch (std::exception& e) {
17252       {
17253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17254       };
17255     } catch (Dali::DaliException e) {
17256       {
17257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17258       };
17259     } catch (...) {
17260       {
17261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17262       };
17263     }
17264   }
17265
17266   jresult = (void *)result;
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17272   void * jresult ;
17273   Dali::Property::Value *arg1 = 0 ;
17274   Dali::Property::Value *result = 0 ;
17275
17276   arg1 = (Dali::Property::Value *)jarg1;
17277   if (!arg1) {
17278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17279     return 0;
17280   }
17281   {
17282     try {
17283       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17284     } catch (std::out_of_range& e) {
17285       {
17286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17287       };
17288     } catch (std::exception& e) {
17289       {
17290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17291       };
17292     } catch (Dali::DaliException e) {
17293       {
17294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17295       };
17296     } catch (...) {
17297       {
17298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17299       };
17300     }
17301   }
17302
17303   jresult = (void *)result;
17304   return jresult;
17305 }
17306
17307
17308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17309   void * jresult ;
17310   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17311   Dali::Property::Value *arg2 = 0 ;
17312   Dali::Property::Value *result = 0 ;
17313
17314   arg1 = (Dali::Property::Value *)jarg1;
17315   arg2 = (Dali::Property::Value *)jarg2;
17316   if (!arg2) {
17317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17318     return 0;
17319   }
17320   {
17321     try {
17322       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17323     } catch (std::out_of_range& e) {
17324       {
17325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17326       };
17327     } catch (std::exception& e) {
17328       {
17329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (Dali::DaliException e) {
17332       {
17333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341
17342   jresult = (void *)result;
17343   return jresult;
17344 }
17345
17346
17347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17348   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17349
17350   arg1 = (Dali::Property::Value *)jarg1;
17351   {
17352     try {
17353       delete arg1;
17354     } catch (std::out_of_range& e) {
17355       {
17356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17357       };
17358     } catch (std::exception& e) {
17359       {
17360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17361       };
17362     } catch (Dali::DaliException e) {
17363       {
17364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17365       };
17366     } catch (...) {
17367       {
17368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17369       };
17370     }
17371   }
17372
17373 }
17374
17375
17376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17377   int jresult ;
17378   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17379   Dali::Property::Type result;
17380
17381   arg1 = (Dali::Property::Value *)jarg1;
17382   {
17383     try {
17384       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17385     } catch (std::out_of_range& e) {
17386       {
17387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17388       };
17389     } catch (std::exception& e) {
17390       {
17391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17392       };
17393     } catch (Dali::DaliException e) {
17394       {
17395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17396       };
17397     } catch (...) {
17398       {
17399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17400       };
17401     }
17402   }
17403
17404   jresult = (int)result;
17405   return jresult;
17406 }
17407
17408
17409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17410   unsigned int jresult ;
17411   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17412   bool *arg2 = 0 ;
17413   bool result;
17414
17415   arg1 = (Dali::Property::Value *)jarg1;
17416   arg2 = (bool *)jarg2;
17417   {
17418     try {
17419       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17420     } catch (std::out_of_range& e) {
17421       {
17422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17423       };
17424     } catch (std::exception& e) {
17425       {
17426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (Dali::DaliException e) {
17429       {
17430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438
17439   jresult = result;
17440   return jresult;
17441 }
17442
17443
17444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17445   unsigned int jresult ;
17446   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17447   float *arg2 = 0 ;
17448   bool result;
17449
17450   arg1 = (Dali::Property::Value *)jarg1;
17451   arg2 = (float *)jarg2;
17452   {
17453     try {
17454       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17455     } catch (std::out_of_range& e) {
17456       {
17457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17458       };
17459     } catch (std::exception& e) {
17460       {
17461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17462       };
17463     } catch (Dali::DaliException e) {
17464       {
17465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17466       };
17467     } catch (...) {
17468       {
17469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17470       };
17471     }
17472   }
17473
17474   jresult = result;
17475   return jresult;
17476 }
17477
17478
17479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17480   unsigned int jresult ;
17481   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17482   int *arg2 = 0 ;
17483   bool result;
17484
17485   arg1 = (Dali::Property::Value *)jarg1;
17486   arg2 = (int *)jarg2;
17487   {
17488     try {
17489       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17490     } catch (std::out_of_range& e) {
17491       {
17492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17493       };
17494     } catch (std::exception& e) {
17495       {
17496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17497       };
17498     } catch (Dali::DaliException e) {
17499       {
17500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17501       };
17502     } catch (...) {
17503       {
17504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17505       };
17506     }
17507   }
17508
17509   jresult = result;
17510   return jresult;
17511 }
17512
17513
17514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17515   unsigned int jresult ;
17516   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17517   Dali::Rect< int > *arg2 = 0 ;
17518   bool result;
17519
17520   arg1 = (Dali::Property::Value *)jarg1;
17521   arg2 = (Dali::Rect< int > *)jarg2;
17522   if (!arg2) {
17523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17524     return 0;
17525   }
17526   {
17527     try {
17528       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17529     } catch (std::out_of_range& e) {
17530       {
17531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (std::exception& e) {
17534       {
17535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17536       };
17537     } catch (Dali::DaliException e) {
17538       {
17539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17544       };
17545     }
17546   }
17547
17548   jresult = result;
17549   return jresult;
17550 }
17551
17552
17553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17554   unsigned int jresult ;
17555   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17556   Dali::Vector2 *arg2 = 0 ;
17557   bool result;
17558
17559   arg1 = (Dali::Property::Value *)jarg1;
17560   arg2 = (Dali::Vector2 *)jarg2;
17561   if (!arg2) {
17562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17563     return 0;
17564   }
17565   {
17566     try {
17567       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17568     } catch (std::out_of_range& e) {
17569       {
17570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17571       };
17572     } catch (std::exception& e) {
17573       {
17574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17575       };
17576     } catch (Dali::DaliException e) {
17577       {
17578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17579       };
17580     } catch (...) {
17581       {
17582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17583       };
17584     }
17585   }
17586
17587   jresult = result;
17588   return jresult;
17589 }
17590
17591
17592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17593   unsigned int jresult ;
17594   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17595   Dali::Vector3 *arg2 = 0 ;
17596   bool result;
17597
17598   arg1 = (Dali::Property::Value *)jarg1;
17599   arg2 = (Dali::Vector3 *)jarg2;
17600   if (!arg2) {
17601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17602     return 0;
17603   }
17604   {
17605     try {
17606       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17607     } catch (std::out_of_range& e) {
17608       {
17609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17610       };
17611     } catch (std::exception& e) {
17612       {
17613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17614       };
17615     } catch (Dali::DaliException e) {
17616       {
17617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17618       };
17619     } catch (...) {
17620       {
17621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17622       };
17623     }
17624   }
17625
17626   jresult = result;
17627   return jresult;
17628 }
17629
17630
17631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17632   unsigned int jresult ;
17633   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17634   Dali::Vector4 *arg2 = 0 ;
17635   bool result;
17636
17637   arg1 = (Dali::Property::Value *)jarg1;
17638   arg2 = (Dali::Vector4 *)jarg2;
17639   if (!arg2) {
17640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17641     return 0;
17642   }
17643   {
17644     try {
17645       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17646     } catch (std::out_of_range& e) {
17647       {
17648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17649       };
17650     } catch (std::exception& e) {
17651       {
17652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17653       };
17654     } catch (Dali::DaliException e) {
17655       {
17656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17657       };
17658     } catch (...) {
17659       {
17660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17661       };
17662     }
17663   }
17664
17665   jresult = result;
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17671   unsigned int jresult ;
17672   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17673   Dali::Matrix3 *arg2 = 0 ;
17674   bool result;
17675
17676   arg1 = (Dali::Property::Value *)jarg1;
17677   arg2 = (Dali::Matrix3 *)jarg2;
17678   if (!arg2) {
17679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17680     return 0;
17681   }
17682   {
17683     try {
17684       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17685     } catch (std::out_of_range& e) {
17686       {
17687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (std::exception& e) {
17690       {
17691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17692       };
17693     } catch (Dali::DaliException e) {
17694       {
17695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17696       };
17697     } catch (...) {
17698       {
17699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17700       };
17701     }
17702   }
17703
17704   jresult = result;
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17710   unsigned int jresult ;
17711   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17712   Dali::Matrix *arg2 = 0 ;
17713   bool result;
17714
17715   arg1 = (Dali::Property::Value *)jarg1;
17716   arg2 = (Dali::Matrix *)jarg2;
17717   if (!arg2) {
17718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17719     return 0;
17720   }
17721   {
17722     try {
17723       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17724     } catch (std::out_of_range& e) {
17725       {
17726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17727       };
17728     } catch (std::exception& e) {
17729       {
17730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17731       };
17732     } catch (Dali::DaliException e) {
17733       {
17734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17735       };
17736     } catch (...) {
17737       {
17738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17739       };
17740     }
17741   }
17742
17743   jresult = result;
17744   return jresult;
17745 }
17746
17747
17748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17749   unsigned int jresult ;
17750   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17751   Dali::AngleAxis *arg2 = 0 ;
17752   bool result;
17753
17754   arg1 = (Dali::Property::Value *)jarg1;
17755   arg2 = (Dali::AngleAxis *)jarg2;
17756   if (!arg2) {
17757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17758     return 0;
17759   }
17760   {
17761     try {
17762       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (Dali::DaliException e) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17774       };
17775     } catch (...) {
17776       {
17777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17778       };
17779     }
17780   }
17781
17782   jresult = result;
17783   return jresult;
17784 }
17785
17786
17787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17788   unsigned int jresult ;
17789   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17790   Dali::Quaternion *arg2 = 0 ;
17791   bool result;
17792
17793   arg1 = (Dali::Property::Value *)jarg1;
17794   arg2 = (Dali::Quaternion *)jarg2;
17795   if (!arg2) {
17796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17797     return 0;
17798   }
17799   {
17800     try {
17801       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17802     } catch (std::out_of_range& e) {
17803       {
17804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17805       };
17806     } catch (std::exception& e) {
17807       {
17808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17809       };
17810     } catch (Dali::DaliException e) {
17811       {
17812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17813       };
17814     } catch (...) {
17815       {
17816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17817       };
17818     }
17819   }
17820
17821   jresult = result;
17822   return jresult;
17823 }
17824
17825
17826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17827   unsigned int jresult ;
17828   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17829   std::string *arg2 = 0 ;
17830   bool result;
17831
17832   arg1 = (Dali::Property::Value *)jarg1;
17833
17834   //typemap in
17835   std::string temp;
17836   arg2 = &temp;
17837
17838   {
17839     try {
17840       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17841     } catch (std::out_of_range& e) {
17842       {
17843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17844       };
17845     } catch (std::exception& e) {
17846       {
17847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17848       };
17849     } catch (Dali::DaliException e) {
17850       {
17851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17852       };
17853     } catch (...) {
17854       {
17855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17856       };
17857     }
17858   }
17859
17860   jresult = result;
17861
17862   //Typemap argout in c++ file.
17863   //This will convert c++ string to c# string
17864   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17865
17866   return jresult;
17867 }
17868
17869
17870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17871   unsigned int jresult ;
17872   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17873   Dali::Property::Array *arg2 = 0 ;
17874   bool result;
17875
17876   arg1 = (Dali::Property::Value *)jarg1;
17877   arg2 = (Dali::Property::Array *)jarg2;
17878   if (!arg2) {
17879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17880     return 0;
17881   }
17882   {
17883     try {
17884       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17885     } catch (std::out_of_range& e) {
17886       {
17887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17888       };
17889     } catch (std::exception& e) {
17890       {
17891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17892       };
17893     } catch (Dali::DaliException e) {
17894       {
17895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17896       };
17897     } catch (...) {
17898       {
17899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17900       };
17901     }
17902   }
17903
17904   jresult = result;
17905   return jresult;
17906 }
17907
17908
17909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17910   unsigned int jresult ;
17911   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17912   Dali::Property::Map *arg2 = 0 ;
17913   bool result;
17914
17915   arg1 = (Dali::Property::Value *)jarg1;
17916   arg2 = (Dali::Property::Map *)jarg2;
17917   if (!arg2) {
17918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17919     return 0;
17920   }
17921   {
17922     try {
17923       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17924     } catch (std::out_of_range& e) {
17925       {
17926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17927       };
17928     } catch (std::exception& e) {
17929       {
17930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17931       };
17932     } catch (Dali::DaliException e) {
17933       {
17934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17935       };
17936     } catch (...) {
17937       {
17938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17939       };
17940     }
17941   }
17942
17943   jresult = result;
17944   return jresult;
17945 }
17946
17947
17948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17949   unsigned int jresult ;
17950   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17951   Extents *arg2 = 0 ;
17952   bool result;
17953
17954   arg1 = (Dali::Property::Value *)jarg1;
17955   arg2 = (Extents *)jarg2;
17956   if (!arg2) {
17957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17958     return 0;
17959   }
17960   {
17961     try {
17962       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17963     } catch (std::out_of_range& e) {
17964       {
17965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17966       };
17967     } catch (std::exception& e) {
17968       {
17969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (...) {
17972       {
17973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17974       };
17975     }
17976   }
17977   jresult = result;
17978   return jresult;
17979 }
17980
17981
17982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17983   void * jresult ;
17984   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17985   Dali::Property::Array *result = 0 ;
17986
17987   arg1 = (Dali::Property::Value *)jarg1;
17988   {
17989     try {
17990       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17991     } catch (std::out_of_range& e) {
17992       {
17993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17994       };
17995     } catch (std::exception& e) {
17996       {
17997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17998       };
17999     } catch (Dali::DaliException e) {
18000       {
18001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18002       };
18003     } catch (...) {
18004       {
18005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18006       };
18007     }
18008   }
18009
18010   jresult = (void *)result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18016   void * jresult ;
18017   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18018   Dali::Property::Map *result = 0 ;
18019
18020   arg1 = (Dali::Property::Value *)jarg1;
18021   {
18022     try {
18023       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18024     } catch (std::out_of_range& e) {
18025       {
18026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (std::exception& e) {
18029       {
18030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18031       };
18032     } catch (Dali::DaliException e) {
18033       {
18034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18035       };
18036     } catch (...) {
18037       {
18038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18039       };
18040     }
18041   }
18042
18043   jresult = (void *)result;
18044   return jresult;
18045 }
18046
18047
18048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18049   char * jresult ;
18050   Dali::Property::Type arg1 ;
18051   char *result = 0 ;
18052
18053   arg1 = (Dali::Property::Type)jarg1;
18054   {
18055     try {
18056       result = (char *)Dali::PropertyTypes::GetName(arg1);
18057     } catch (std::out_of_range& e) {
18058       {
18059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (std::exception& e) {
18062       {
18063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18064       };
18065     } catch (Dali::DaliException e) {
18066       {
18067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18068       };
18069     } catch (...) {
18070       {
18071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18072       };
18073     }
18074   }
18075
18076   jresult = SWIG_csharp_string_callback((const char *)result);
18077   return jresult;
18078 }
18079
18080
18081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18082   unsigned int jresult ;
18083   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18084   std::string *arg2 = 0 ;
18085   Dali::Property::Map *arg3 = 0 ;
18086   bool result;
18087
18088   arg1 = (Dali::BaseObject *)jarg1;
18089   if (!jarg2) {
18090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18091     return 0;
18092   }
18093   std::string arg2_str(jarg2);
18094   arg2 = &arg2_str;
18095   arg3 = (Dali::Property::Map *)jarg3;
18096   if (!arg3) {
18097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18098     return 0;
18099   }
18100   {
18101     try {
18102       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18103     } catch (std::out_of_range& e) {
18104       {
18105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (std::exception& e) {
18108       {
18109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18110       };
18111     } catch (Dali::DaliException e) {
18112       {
18113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18114       };
18115     } catch (...) {
18116       {
18117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18118       };
18119     }
18120   }
18121
18122   jresult = result;
18123
18124   //argout typemap for const std::string&
18125
18126   return jresult;
18127 }
18128
18129
18130 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18131   char * jresult ;
18132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18133   std::string *result = 0 ;
18134
18135   arg1 = (Dali::BaseObject *)jarg1;
18136   {
18137     try {
18138       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18139     } catch (std::out_of_range& e) {
18140       {
18141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18142       };
18143     } catch (std::exception& e) {
18144       {
18145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18146       };
18147     } catch (Dali::DaliException e) {
18148       {
18149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18150       };
18151     } catch (...) {
18152       {
18153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18154       };
18155     }
18156   }
18157
18158   jresult = SWIG_csharp_string_callback(result->c_str());
18159   return jresult;
18160 }
18161
18162
18163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18164   unsigned int jresult ;
18165   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18166   Dali::TypeInfo *arg2 = 0 ;
18167   bool result;
18168
18169   arg1 = (Dali::BaseObject *)jarg1;
18170   arg2 = (Dali::TypeInfo *)jarg2;
18171   if (!arg2) {
18172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18173     return 0;
18174   }
18175   {
18176     try {
18177       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18178     } catch (std::out_of_range& e) {
18179       {
18180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18181       };
18182     } catch (std::exception& e) {
18183       {
18184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18185       };
18186     } catch (Dali::DaliException e) {
18187       {
18188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18189       };
18190     } catch (...) {
18191       {
18192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18193       };
18194     }
18195   }
18196
18197   jresult = result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18203   unsigned int jresult ;
18204   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18205   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18206   std::string *arg3 = 0 ;
18207   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18208   bool result;
18209
18210   arg1 = (Dali::BaseObject *)jarg1;
18211   arg2 = (ConnectionTrackerInterface *)jarg2;
18212   if (!jarg3) {
18213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18214     return 0;
18215   }
18216   std::string arg3_str(jarg3);
18217   arg3 = &arg3_str;
18218   arg4 = (FunctorDelegate *)jarg4;
18219   {
18220     try {
18221       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18222     } catch (std::out_of_range& e) {
18223       {
18224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18225       };
18226     } catch (std::exception& e) {
18227       {
18228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18229       };
18230     } catch (Dali::DaliException e) {
18231       {
18232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18233       };
18234     } catch (...) {
18235       {
18236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18237       };
18238     }
18239   }
18240
18241   jresult = result;
18242
18243   //argout typemap for const std::string&
18244
18245   return jresult;
18246 }
18247
18248
18249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18250   void * jresult ;
18251   Dali::BaseHandle *arg1 = 0 ;
18252   Dali::BaseObject *result = 0 ;
18253
18254   arg1 = (Dali::BaseHandle *)jarg1;
18255   if (!arg1) {
18256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18257     return 0;
18258   }
18259   {
18260     try {
18261       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18262     } catch (std::out_of_range& e) {
18263       {
18264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (std::exception& e) {
18267       {
18268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (Dali::DaliException e) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18273       };
18274     } catch (...) {
18275       {
18276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18277       };
18278     }
18279   }
18280
18281   jresult = (void *)result;
18282   return jresult;
18283 }
18284
18285
18286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18287   void * jresult ;
18288   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18289   Dali::BaseHandle *result = 0 ;
18290
18291   arg1 = (Dali::BaseObject *)jarg1;
18292   {
18293     try {
18294       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18295     } catch (std::out_of_range& e) {
18296       {
18297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18298       };
18299     } catch (std::exception& e) {
18300       {
18301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18302       };
18303     } catch (Dali::DaliException e) {
18304       {
18305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18306       };
18307     } catch (...) {
18308       {
18309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18310       };
18311     }
18312   }
18313
18314   jresult = (void *)result;
18315   return jresult;
18316 }
18317
18318
18319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18320   void * jresult ;
18321   Dali::BaseHandle *result = 0 ;
18322
18323   {
18324     try {
18325       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18326     } catch (std::out_of_range& e) {
18327       {
18328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18329       };
18330     } catch (std::exception& e) {
18331       {
18332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18333       };
18334     } catch (Dali::DaliException e) {
18335       {
18336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18337       };
18338     } catch (...) {
18339       {
18340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18341       };
18342     }
18343   }
18344
18345   jresult = (void *)result;
18346   return jresult;
18347 }
18348
18349
18350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18351   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18352
18353   arg1 = (Dali::BaseHandle *)jarg1;
18354   {
18355     try {
18356       delete arg1;
18357     } catch (std::out_of_range& e) {
18358       {
18359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18360       };
18361     } catch (std::exception& e) {
18362       {
18363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18364       };
18365     } catch (Dali::DaliException e) {
18366       {
18367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18368       };
18369     } catch (...) {
18370       {
18371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18372       };
18373     }
18374   }
18375
18376 }
18377
18378
18379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18380   void * jresult ;
18381   Dali::BaseHandle *arg1 = 0 ;
18382   Dali::BaseHandle *result = 0 ;
18383
18384   arg1 = (Dali::BaseHandle *)jarg1;
18385   if (!arg1) {
18386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18387     return 0;
18388   }
18389   {
18390     try {
18391       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18392     } catch (std::out_of_range& e) {
18393       {
18394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18395       };
18396     } catch (std::exception& e) {
18397       {
18398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18399       };
18400     } catch (Dali::DaliException e) {
18401       {
18402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18403       };
18404     } catch (...) {
18405       {
18406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18407       };
18408     }
18409   }
18410
18411   jresult = (void *)result;
18412   return jresult;
18413 }
18414
18415
18416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18417   void * jresult ;
18418   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18419   Dali::BaseHandle *arg2 = 0 ;
18420   Dali::BaseHandle *result = 0 ;
18421
18422   arg1 = (Dali::BaseHandle *)jarg1;
18423   arg2 = (Dali::BaseHandle *)jarg2;
18424   if (!arg2) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (Dali::DaliException e) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18442       };
18443     } catch (...) {
18444       {
18445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18446       };
18447     }
18448   }
18449
18450   jresult = (void *)result;
18451   return jresult;
18452 }
18453
18454
18455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18456   unsigned int jresult ;
18457   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18458   std::string *arg2 = 0 ;
18459   Dali::Property::Map *arg3 = 0 ;
18460   bool result;
18461
18462   arg1 = (Dali::BaseHandle *)jarg1;
18463   if (!jarg2) {
18464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18465     return 0;
18466   }
18467   std::string arg2_str(jarg2);
18468   arg2 = &arg2_str;
18469   arg3 = (Dali::Property::Map *)jarg3;
18470   if (!arg3) {
18471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18472     return 0;
18473   }
18474   {
18475     try {
18476       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18477     } catch (std::out_of_range& e) {
18478       {
18479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18480       };
18481     } catch (std::exception& e) {
18482       {
18483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18484       };
18485     } catch (Dali::DaliException e) {
18486       {
18487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18488       };
18489     } catch (...) {
18490       {
18491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18492       };
18493     }
18494   }
18495
18496   jresult = result;
18497
18498   //argout typemap for const std::string&
18499
18500   return jresult;
18501 }
18502
18503
18504 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18505   char * jresult ;
18506   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18507   std::string *result = 0 ;
18508
18509   arg1 = (Dali::BaseHandle *)jarg1;
18510   {
18511     try {
18512       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18513     } catch (std::out_of_range& e) {
18514       {
18515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18516       };
18517     } catch (std::exception& e) {
18518       {
18519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18520       };
18521     } catch (Dali::DaliException e) {
18522       {
18523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18524       };
18525     } catch (...) {
18526       {
18527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18528       };
18529     }
18530   }
18531
18532   jresult = SWIG_csharp_string_callback(result->c_str());
18533   return jresult;
18534 }
18535
18536
18537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18538   unsigned int jresult ;
18539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18540   Dali::TypeInfo *arg2 = 0 ;
18541   bool result;
18542
18543   arg1 = (Dali::BaseHandle *)jarg1;
18544   arg2 = (Dali::TypeInfo *)jarg2;
18545   if (!arg2) {
18546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18547     return 0;
18548   }
18549   {
18550     try {
18551       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18552     } catch (std::out_of_range& e) {
18553       {
18554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18555       };
18556     } catch (std::exception& e) {
18557       {
18558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18559       };
18560     } catch (Dali::DaliException e) {
18561       {
18562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18563       };
18564     } catch (...) {
18565       {
18566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18567       };
18568     }
18569   }
18570
18571   jresult = result;
18572   return jresult;
18573 }
18574
18575
18576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18577   void * jresult ;
18578   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18579   Dali::BaseObject *result = 0 ;
18580
18581   arg1 = (Dali::BaseHandle *)jarg1;
18582   {
18583     try {
18584       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18585     } catch (std::out_of_range& e) {
18586       {
18587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18588       };
18589     } catch (std::exception& e) {
18590       {
18591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18592       };
18593     } catch (Dali::DaliException e) {
18594       {
18595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18596       };
18597     } catch (...) {
18598       {
18599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18600       };
18601     }
18602   }
18603
18604   jresult = (void *)result;
18605   return jresult;
18606 }
18607
18608
18609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18610   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18611
18612   arg1 = (Dali::BaseHandle *)jarg1;
18613   {
18614     try {
18615       (arg1)->Reset();
18616     } catch (std::out_of_range& e) {
18617       {
18618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18619       };
18620     } catch (std::exception& e) {
18621       {
18622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18623       };
18624     } catch (Dali::DaliException e) {
18625       {
18626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18627       };
18628     } catch (...) {
18629       {
18630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18631       };
18632     }
18633   }
18634
18635 }
18636
18637
18638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18639   unsigned int jresult ;
18640   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18641   Dali::BaseHandle *arg2 = 0 ;
18642   bool result;
18643
18644   arg1 = (Dali::BaseHandle *)jarg1;
18645   arg2 = (Dali::BaseHandle *)jarg2;
18646   if (!arg2) {
18647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18648     return 0;
18649   }
18650   {
18651     try {
18652       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18653     } catch (std::out_of_range& e) {
18654       {
18655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18656       };
18657     } catch (std::exception& e) {
18658       {
18659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18660       };
18661     } catch (Dali::DaliException e) {
18662       {
18663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18664       };
18665     } catch (...) {
18666       {
18667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18668       };
18669     }
18670   }
18671
18672   jresult = result;
18673   return jresult;
18674 }
18675
18676
18677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18678   unsigned int jresult ;
18679   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18680   Dali::BaseHandle *arg2 = 0 ;
18681   bool result;
18682
18683   arg1 = (Dali::BaseHandle *)jarg1;
18684   arg2 = (Dali::BaseHandle *)jarg2;
18685   if (!arg2) {
18686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18687     return 0;
18688   }
18689   {
18690     try {
18691       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18692     } catch (std::out_of_range& e) {
18693       {
18694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18695       };
18696     } catch (std::exception& e) {
18697       {
18698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18699       };
18700     } catch (Dali::DaliException e) {
18701       {
18702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18703       };
18704     } catch (...) {
18705       {
18706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18707       };
18708     }
18709   }
18710
18711   jresult = result;
18712   return jresult;
18713 }
18714
18715
18716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18717   void * jresult ;
18718   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18719   Dali::RefObject *result = 0 ;
18720
18721   arg1 = (Dali::BaseHandle *)jarg1;
18722   {
18723     try {
18724       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18725     } catch (std::out_of_range& e) {
18726       {
18727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18728       };
18729     } catch (std::exception& e) {
18730       {
18731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (Dali::DaliException e) {
18734       {
18735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18736       };
18737     } catch (...) {
18738       {
18739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18740       };
18741     }
18742   }
18743
18744   jresult = (void *)result;
18745   return jresult;
18746 }
18747
18748
18749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18750   unsigned int jresult ;
18751   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18752   bool result;
18753
18754   arg1 = (Dali::BaseHandle *)jarg1;
18755   {
18756     try {
18757       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18758     } catch (std::out_of_range& e) {
18759       {
18760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (std::exception& e) {
18763       {
18764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18765       };
18766     } catch (Dali::DaliException e) {
18767       {
18768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18769       };
18770     } catch (...) {
18771       {
18772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18773       };
18774     }
18775   }
18776
18777   jresult = result;
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18783   unsigned int jresult ;
18784   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18785   Dali::BaseHandle *arg2 = 0 ;
18786   bool result;
18787
18788   arg1 = (Dali::BaseHandle *)jarg1;
18789   arg2 = (Dali::BaseHandle *)jarg2;
18790   if (!arg2) {
18791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18792     return 0;
18793   }
18794   {
18795     try {
18796       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18797     } catch (std::out_of_range& e) {
18798       {
18799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18800       };
18801     } catch (std::exception& e) {
18802       {
18803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (Dali::DaliException e) {
18806       {
18807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18808       };
18809     } catch (...) {
18810       {
18811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18812       };
18813     }
18814   }
18815
18816   jresult = result;
18817   return jresult;
18818 }
18819
18820
18821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18822   unsigned int jresult ;
18823   Dali::BaseHandle *arg1 = 0 ;
18824   Dali::BaseHandle *arg2 = 0 ;
18825   bool result;
18826
18827   arg1 = (Dali::BaseHandle *)jarg1;
18828   if (!arg1) {
18829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18830     return 0;
18831   }
18832   arg2 = (Dali::BaseHandle *)jarg2;
18833   if (!arg2) {
18834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18835     return 0;
18836   }
18837   {
18838     try {
18839       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18840     } catch (std::out_of_range& e) {
18841       {
18842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18843       };
18844     } catch (std::exception& e) {
18845       {
18846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18847       };
18848     } catch (Dali::DaliException e) {
18849       {
18850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18851       };
18852     } catch (...) {
18853       {
18854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18855       };
18856     }
18857   }
18858
18859   jresult = result;
18860   return jresult;
18861 }
18862
18863
18864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18865   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18866
18867   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18868   {
18869     try {
18870       delete arg1;
18871     } catch (std::out_of_range& e) {
18872       {
18873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18874       };
18875     } catch (std::exception& e) {
18876       {
18877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18878       };
18879     } catch (Dali::DaliException e) {
18880       {
18881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18882       };
18883     } catch (...) {
18884       {
18885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18886       };
18887     }
18888   }
18889
18890 }
18891
18892
18893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18894   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18895   SlotObserver *arg2 = (SlotObserver *) 0 ;
18896   CallbackBase *arg3 = (CallbackBase *) 0 ;
18897
18898   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18899   arg2 = (SlotObserver *)jarg2;
18900   arg3 = (CallbackBase *)jarg3;
18901   {
18902     try {
18903       (arg1)->SignalConnected(arg2,arg3);
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18911       };
18912     } catch (Dali::DaliException e) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18915       };
18916     } catch (...) {
18917       {
18918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18919       };
18920     }
18921   }
18922
18923 }
18924
18925
18926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18927   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18928
18929   arg1 = (Dali::SignalObserver *)jarg1;
18930   {
18931     try {
18932       delete arg1;
18933     } catch (std::out_of_range& e) {
18934       {
18935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18936       };
18937     } catch (std::exception& e) {
18938       {
18939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18940       };
18941     } catch (Dali::DaliException e) {
18942       {
18943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18944       };
18945     } catch (...) {
18946       {
18947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18948       };
18949     }
18950   }
18951
18952 }
18953
18954
18955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18956   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18957   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18958   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18959
18960   arg1 = (Dali::SignalObserver *)jarg1;
18961   arg2 = (Dali::SlotObserver *)jarg2;
18962   arg3 = (Dali::CallbackBase *)jarg3;
18963   {
18964     try {
18965       (arg1)->SignalDisconnected(arg2,arg3);
18966     } catch (std::out_of_range& e) {
18967       {
18968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18969       };
18970     } catch (std::exception& e) {
18971       {
18972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18973       };
18974     } catch (Dali::DaliException e) {
18975       {
18976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18977       };
18978     } catch (...) {
18979       {
18980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18981       };
18982     }
18983   }
18984
18985 }
18986
18987
18988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18989   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18990
18991   arg1 = (Dali::SlotObserver *)jarg1;
18992   {
18993     try {
18994       delete arg1;
18995     } catch (std::out_of_range& e) {
18996       {
18997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18998       };
18999     } catch (std::exception& e) {
19000       {
19001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19002       };
19003     } catch (Dali::DaliException e) {
19004       {
19005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19006       };
19007     } catch (...) {
19008       {
19009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19010       };
19011     }
19012   }
19013
19014 }
19015
19016
19017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19018   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19019   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19020
19021   arg1 = (Dali::SlotObserver *)jarg1;
19022   arg2 = (Dali::CallbackBase *)jarg2;
19023   {
19024     try {
19025       (arg1)->SlotDisconnected(arg2);
19026     } catch (std::out_of_range& e) {
19027       {
19028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19029       };
19030     } catch (std::exception& e) {
19031       {
19032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19033       };
19034     } catch (Dali::DaliException e) {
19035       {
19036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19037       };
19038     } catch (...) {
19039       {
19040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19041       };
19042     }
19043   }
19044
19045 }
19046
19047
19048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19049   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19050
19051   arg1 = (Dali::ConnectionTracker *)jarg1;
19052   {
19053     try {
19054       delete arg1;
19055     } catch (std::out_of_range& e) {
19056       {
19057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19058       };
19059     } catch (std::exception& e) {
19060       {
19061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19062       };
19063     } catch (Dali::DaliException e) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19066       };
19067     } catch (...) {
19068       {
19069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19070       };
19071     }
19072   }
19073
19074 }
19075
19076
19077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19078   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19079
19080   arg1 = (Dali::ConnectionTracker *)jarg1;
19081   {
19082     try {
19083       (arg1)->DisconnectAll();
19084     } catch (std::out_of_range& e) {
19085       {
19086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19087       };
19088     } catch (std::exception& e) {
19089       {
19090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19091       };
19092     } catch (Dali::DaliException e) {
19093       {
19094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19095       };
19096     } catch (...) {
19097       {
19098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19099       };
19100     }
19101   }
19102
19103 }
19104
19105
19106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19107   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19108   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19109   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19110
19111   arg1 = (Dali::ConnectionTracker *)jarg1;
19112   arg2 = (Dali::SlotObserver *)jarg2;
19113   arg3 = (Dali::CallbackBase *)jarg3;
19114   {
19115     try {
19116       (arg1)->SignalConnected(arg2,arg3);
19117     } catch (std::out_of_range& e) {
19118       {
19119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19120       };
19121     } catch (std::exception& e) {
19122       {
19123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19124       };
19125     } catch (Dali::DaliException e) {
19126       {
19127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19132       };
19133     }
19134   }
19135
19136 }
19137
19138
19139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19140   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19141   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19142   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19143
19144   arg1 = (Dali::ConnectionTracker *)jarg1;
19145   arg2 = (Dali::SlotObserver *)jarg2;
19146   arg3 = (Dali::CallbackBase *)jarg3;
19147   {
19148     try {
19149       (arg1)->SignalDisconnected(arg2,arg3);
19150     } catch (std::out_of_range& e) {
19151       {
19152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19153       };
19154     } catch (std::exception& e) {
19155       {
19156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19157       };
19158     } catch (Dali::DaliException e) {
19159       {
19160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19165       };
19166     }
19167   }
19168
19169 }
19170
19171
19172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19173   unsigned long jresult ;
19174   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19175   std::size_t result;
19176
19177   arg1 = (Dali::ConnectionTracker *)jarg1;
19178   {
19179     try {
19180       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19181     } catch (std::out_of_range& e) {
19182       {
19183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19184       };
19185     } catch (std::exception& e) {
19186       {
19187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19188       };
19189     } catch (Dali::DaliException e) {
19190       {
19191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19192       };
19193     } catch (...) {
19194       {
19195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19196       };
19197     }
19198   }
19199
19200   jresult = (unsigned long)result;
19201   return jresult;
19202 }
19203
19204
19205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19206   void * jresult ;
19207   Dali::ObjectRegistry *result = 0 ;
19208
19209   {
19210     try {
19211       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19212     } catch (std::out_of_range& e) {
19213       {
19214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19215       };
19216     } catch (std::exception& e) {
19217       {
19218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19219       };
19220     } catch (Dali::DaliException e) {
19221       {
19222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19223       };
19224     } catch (...) {
19225       {
19226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19227       };
19228     }
19229   }
19230
19231   jresult = (void *)result;
19232   return jresult;
19233 }
19234
19235
19236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19237   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19238
19239   arg1 = (Dali::ObjectRegistry *)jarg1;
19240   {
19241     try {
19242       delete arg1;
19243     } catch (std::out_of_range& e) {
19244       {
19245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19246       };
19247     } catch (std::exception& e) {
19248       {
19249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19250       };
19251     } catch (Dali::DaliException e) {
19252       {
19253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19254       };
19255     } catch (...) {
19256       {
19257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19258       };
19259     }
19260   }
19261
19262 }
19263
19264
19265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19266   void * jresult ;
19267   Dali::ObjectRegistry *arg1 = 0 ;
19268   Dali::ObjectRegistry *result = 0 ;
19269
19270   arg1 = (Dali::ObjectRegistry *)jarg1;
19271   if (!arg1) {
19272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19273     return 0;
19274   }
19275   {
19276     try {
19277       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19278     } catch (std::out_of_range& e) {
19279       {
19280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19281       };
19282     } catch (std::exception& e) {
19283       {
19284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19285       };
19286     } catch (Dali::DaliException e) {
19287       {
19288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19289       };
19290     } catch (...) {
19291       {
19292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19293       };
19294     }
19295   }
19296
19297   jresult = (void *)result;
19298   return jresult;
19299 }
19300
19301
19302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19303   void * jresult ;
19304   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19305   Dali::ObjectRegistry *arg2 = 0 ;
19306   Dali::ObjectRegistry *result = 0 ;
19307
19308   arg1 = (Dali::ObjectRegistry *)jarg1;
19309   arg2 = (Dali::ObjectRegistry *)jarg2;
19310   if (!arg2) {
19311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19312     return 0;
19313   }
19314   {
19315     try {
19316       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19317     } catch (std::out_of_range& e) {
19318       {
19319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (std::exception& e) {
19322       {
19323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19324       };
19325     } catch (Dali::DaliException e) {
19326       {
19327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19328       };
19329     } catch (...) {
19330       {
19331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19332       };
19333     }
19334   }
19335
19336   jresult = (void *)result;
19337   return jresult;
19338 }
19339
19340
19341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19342   void * jresult ;
19343   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19344   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19345
19346   arg1 = (Dali::ObjectRegistry *)jarg1;
19347   {
19348     try {
19349       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19350     } catch (std::out_of_range& e) {
19351       {
19352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19353       };
19354     } catch (std::exception& e) {
19355       {
19356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (Dali::DaliException e) {
19359       {
19360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19375   void * jresult ;
19376   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19377   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19378
19379   arg1 = (Dali::ObjectRegistry *)jarg1;
19380   {
19381     try {
19382       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19383     } catch (std::out_of_range& e) {
19384       {
19385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19386       };
19387     } catch (std::exception& e) {
19388       {
19389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19390       };
19391     } catch (Dali::DaliException e) {
19392       {
19393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19394       };
19395     } catch (...) {
19396       {
19397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19398       };
19399     }
19400   }
19401
19402   jresult = (void *)result;
19403   return jresult;
19404 }
19405
19406
19407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19408   void * jresult ;
19409   Dali::PropertyCondition *result = 0 ;
19410
19411   {
19412     try {
19413       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19414     } catch (std::out_of_range& e) {
19415       {
19416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19417       };
19418     } catch (std::exception& e) {
19419       {
19420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19421       };
19422     } catch (Dali::DaliException e) {
19423       {
19424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19425       };
19426     } catch (...) {
19427       {
19428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19429       };
19430     }
19431   }
19432
19433   jresult = (void *)result;
19434   return jresult;
19435 }
19436
19437
19438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19439   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19440
19441   arg1 = (Dali::PropertyCondition *)jarg1;
19442   {
19443     try {
19444       delete arg1;
19445     } catch (std::out_of_range& e) {
19446       {
19447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19448       };
19449     } catch (std::exception& e) {
19450       {
19451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19452       };
19453     } catch (Dali::DaliException e) {
19454       {
19455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19460       };
19461     }
19462   }
19463
19464 }
19465
19466
19467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19468   void * jresult ;
19469   Dali::PropertyCondition *arg1 = 0 ;
19470   Dali::PropertyCondition *result = 0 ;
19471
19472   arg1 = (Dali::PropertyCondition *)jarg1;
19473   if (!arg1) {
19474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19475     return 0;
19476   }
19477   {
19478     try {
19479       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19480     } catch (std::out_of_range& e) {
19481       {
19482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19483       };
19484     } catch (std::exception& e) {
19485       {
19486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19487       };
19488     } catch (Dali::DaliException e) {
19489       {
19490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19491       };
19492     } catch (...) {
19493       {
19494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19495       };
19496     }
19497   }
19498
19499   jresult = (void *)result;
19500   return jresult;
19501 }
19502
19503
19504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19505   void * jresult ;
19506   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19507   Dali::PropertyCondition *arg2 = 0 ;
19508   Dali::PropertyCondition *result = 0 ;
19509
19510   arg1 = (Dali::PropertyCondition *)jarg1;
19511   arg2 = (Dali::PropertyCondition *)jarg2;
19512   if (!arg2) {
19513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19514     return 0;
19515   }
19516   {
19517     try {
19518       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19519     } catch (std::out_of_range& e) {
19520       {
19521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19522       };
19523     } catch (std::exception& e) {
19524       {
19525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19526       };
19527     } catch (Dali::DaliException e) {
19528       {
19529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19530       };
19531     } catch (...) {
19532       {
19533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19534       };
19535     }
19536   }
19537
19538   jresult = (void *)result;
19539   return jresult;
19540 }
19541
19542
19543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19544   unsigned long jresult ;
19545   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19546   std::size_t result;
19547
19548   arg1 = (Dali::PropertyCondition *)jarg1;
19549   {
19550     try {
19551       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19552     } catch (std::out_of_range& e) {
19553       {
19554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19555       };
19556     } catch (std::exception& e) {
19557       {
19558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (...) {
19561       {
19562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19563       };
19564     }
19565   }
19566   jresult = (unsigned long)result;
19567   return jresult;
19568 }
19569
19570
19571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19572   float jresult ;
19573   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19574   std::size_t arg2 ;
19575   float result;
19576
19577   arg1 = (Dali::PropertyCondition *)jarg1;
19578   arg2 = (std::size_t)jarg2;
19579   {
19580     try {
19581       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19582     } catch (std::out_of_range& e) {
19583       {
19584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19585       };
19586     } catch (std::exception& e) {
19587       {
19588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (...) {
19591       {
19592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19593       };
19594     }
19595   }
19596   jresult = result;
19597   return jresult;
19598 }
19599
19600
19601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19602   void * jresult ;
19603   float arg1 ;
19604   Dali::PropertyCondition result;
19605
19606   arg1 = (float)jarg1;
19607   {
19608     try {
19609       result = Dali::LessThanCondition(arg1);
19610     } catch (std::out_of_range& e) {
19611       {
19612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19613       };
19614     } catch (std::exception& e) {
19615       {
19616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19617       };
19618     } catch (Dali::DaliException e) {
19619       {
19620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19621       };
19622     } catch (...) {
19623       {
19624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19625       };
19626     }
19627   }
19628
19629   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19630   return jresult;
19631 }
19632
19633
19634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19635   void * jresult ;
19636   float arg1 ;
19637   Dali::PropertyCondition result;
19638
19639   arg1 = (float)jarg1;
19640   {
19641     try {
19642       result = Dali::GreaterThanCondition(arg1);
19643     } catch (std::out_of_range& e) {
19644       {
19645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19646       };
19647     } catch (std::exception& e) {
19648       {
19649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19650       };
19651     } catch (Dali::DaliException e) {
19652       {
19653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19658       };
19659     }
19660   }
19661
19662   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19663   return jresult;
19664 }
19665
19666
19667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19668   void * jresult ;
19669   float arg1 ;
19670   float arg2 ;
19671   Dali::PropertyCondition result;
19672
19673   arg1 = (float)jarg1;
19674   arg2 = (float)jarg2;
19675   {
19676     try {
19677       result = Dali::InsideCondition(arg1,arg2);
19678     } catch (std::out_of_range& e) {
19679       {
19680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19681       };
19682     } catch (std::exception& e) {
19683       {
19684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19685       };
19686     } catch (Dali::DaliException e) {
19687       {
19688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19689       };
19690     } catch (...) {
19691       {
19692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19693       };
19694     }
19695   }
19696
19697   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19698   return jresult;
19699 }
19700
19701
19702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19703   void * jresult ;
19704   float arg1 ;
19705   float arg2 ;
19706   Dali::PropertyCondition result;
19707
19708   arg1 = (float)jarg1;
19709   arg2 = (float)jarg2;
19710   {
19711     try {
19712       result = Dali::OutsideCondition(arg1,arg2);
19713     } catch (std::out_of_range& e) {
19714       {
19715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19716       };
19717     } catch (std::exception& e) {
19718       {
19719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19720       };
19721     } catch (Dali::DaliException e) {
19722       {
19723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19724       };
19725     } catch (...) {
19726       {
19727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19728       };
19729     }
19730   }
19731
19732   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19733   return jresult;
19734 }
19735
19736
19737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19738   void * jresult ;
19739   float arg1 ;
19740   float arg2 ;
19741   Dali::PropertyCondition result;
19742
19743   arg1 = (float)jarg1;
19744   arg2 = (float)jarg2;
19745   {
19746     try {
19747       result = Dali::StepCondition(arg1,arg2);
19748     } catch (std::out_of_range& e) {
19749       {
19750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19751       };
19752     } catch (std::exception& e) {
19753       {
19754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19755       };
19756     } catch (Dali::DaliException e) {
19757       {
19758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19759       };
19760     } catch (...) {
19761       {
19762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19763       };
19764     }
19765   }
19766
19767   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19768   return jresult;
19769 }
19770
19771
19772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19773   void * jresult ;
19774   float arg1 ;
19775   Dali::PropertyCondition result;
19776
19777   arg1 = (float)jarg1;
19778   {
19779     try {
19780       result = Dali::StepCondition(arg1);
19781     } catch (std::out_of_range& e) {
19782       {
19783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19784       };
19785     } catch (std::exception& e) {
19786       {
19787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19788       };
19789     } catch (Dali::DaliException e) {
19790       {
19791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19792       };
19793     } catch (...) {
19794       {
19795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19796       };
19797     }
19798   }
19799
19800   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19801   return jresult;
19802 }
19803
19804
19805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19806   void * jresult ;
19807   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19808   Dali::PropertyCondition result;
19809
19810   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19811   if (!arg1) {
19812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19813     return 0;
19814   }
19815   {
19816     try {
19817       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19818     } catch (std::out_of_range& e) {
19819       {
19820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19821       };
19822     } catch (std::exception& e) {
19823       {
19824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19825       };
19826     } catch (Dali::DaliException e) {
19827       {
19828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19829       };
19830     } catch (...) {
19831       {
19832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19833       };
19834     }
19835   }
19836
19837   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19838   return jresult;
19839 }
19840
19841
19842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19843   void * jresult ;
19844   Dali::PropertyNotification *result = 0 ;
19845
19846   {
19847     try {
19848       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19849     } catch (std::out_of_range& e) {
19850       {
19851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19852       };
19853     } catch (std::exception& e) {
19854       {
19855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19856       };
19857     } catch (Dali::DaliException e) {
19858       {
19859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19860       };
19861     } catch (...) {
19862       {
19863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19864       };
19865     }
19866   }
19867
19868   jresult = (void *)result;
19869   return jresult;
19870 }
19871
19872
19873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19874   void * jresult ;
19875   Dali::BaseHandle arg1 ;
19876   Dali::BaseHandle *argp1 ;
19877   Dali::PropertyNotification result;
19878
19879   argp1 = (Dali::BaseHandle *)jarg1;
19880   if (!argp1) {
19881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19882     return 0;
19883   }
19884   arg1 = *argp1;
19885   {
19886     try {
19887       result = Dali::PropertyNotification::DownCast(arg1);
19888     } catch (std::out_of_range& e) {
19889       {
19890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19891       };
19892     } catch (std::exception& e) {
19893       {
19894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19895       };
19896     } catch (Dali::DaliException e) {
19897       {
19898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19899       };
19900     } catch (...) {
19901       {
19902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19903       };
19904     }
19905   }
19906
19907   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19908   return jresult;
19909 }
19910
19911
19912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19913   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19914
19915   arg1 = (Dali::PropertyNotification *)jarg1;
19916   {
19917     try {
19918       delete arg1;
19919     } catch (std::out_of_range& e) {
19920       {
19921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19922       };
19923     } catch (std::exception& e) {
19924       {
19925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19926       };
19927     } catch (Dali::DaliException e) {
19928       {
19929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19930       };
19931     } catch (...) {
19932       {
19933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19934       };
19935     }
19936   }
19937
19938 }
19939
19940
19941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19942   void * jresult ;
19943   Dali::PropertyNotification *arg1 = 0 ;
19944   Dali::PropertyNotification *result = 0 ;
19945
19946   arg1 = (Dali::PropertyNotification *)jarg1;
19947   if (!arg1) {
19948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19949     return 0;
19950   }
19951   {
19952     try {
19953       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19954     } catch (std::out_of_range& e) {
19955       {
19956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19957       };
19958     } catch (std::exception& e) {
19959       {
19960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19961       };
19962     } catch (Dali::DaliException e) {
19963       {
19964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19965       };
19966     } catch (...) {
19967       {
19968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19969       };
19970     }
19971   }
19972
19973   jresult = (void *)result;
19974   return jresult;
19975 }
19976
19977
19978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19979   void * jresult ;
19980   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19981   Dali::PropertyNotification *arg2 = 0 ;
19982   Dali::PropertyNotification *result = 0 ;
19983
19984   arg1 = (Dali::PropertyNotification *)jarg1;
19985   arg2 = (Dali::PropertyNotification *)jarg2;
19986   if (!arg2) {
19987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19988     return 0;
19989   }
19990   {
19991     try {
19992       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19993     } catch (std::out_of_range& e) {
19994       {
19995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19996       };
19997     } catch (std::exception& e) {
19998       {
19999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20000       };
20001     } catch (Dali::DaliException e) {
20002       {
20003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20004       };
20005     } catch (...) {
20006       {
20007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20008       };
20009     }
20010   }
20011
20012   jresult = (void *)result;
20013   return jresult;
20014 }
20015
20016
20017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20018   void * jresult ;
20019   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20020   Dali::PropertyCondition result;
20021
20022   arg1 = (Dali::PropertyNotification *)jarg1;
20023   {
20024     try {
20025       result = (arg1)->GetCondition();
20026     } catch (std::out_of_range& e) {
20027       {
20028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (std::exception& e) {
20031       {
20032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20033       };
20034     } catch (Dali::DaliException e) {
20035       {
20036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20037       };
20038     } catch (...) {
20039       {
20040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20041       };
20042     }
20043   }
20044
20045   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20046   return jresult;
20047 }
20048
20049
20050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20051   void * jresult ;
20052   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20053   Dali::Handle result;
20054
20055   arg1 = (Dali::PropertyNotification *)jarg1;
20056   {
20057     try {
20058       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20059     } catch (std::out_of_range& e) {
20060       {
20061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20062       };
20063     } catch (std::exception& e) {
20064       {
20065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20066       };
20067     } catch (Dali::DaliException e) {
20068       {
20069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20070       };
20071     } catch (...) {
20072       {
20073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20074       };
20075     }
20076   }
20077
20078   jresult = new Dali::Handle((const Dali::Handle &)result);
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20084   int jresult ;
20085   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20086   Dali::Property::Index result;
20087
20088   arg1 = (Dali::PropertyNotification *)jarg1;
20089   {
20090     try {
20091       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20092     } catch (std::out_of_range& e) {
20093       {
20094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20095       };
20096     } catch (std::exception& e) {
20097       {
20098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20099       };
20100     } catch (Dali::DaliException e) {
20101       {
20102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20103       };
20104     } catch (...) {
20105       {
20106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20107       };
20108     }
20109   }
20110
20111   jresult = result;
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20117   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20118   Dali::PropertyNotification::NotifyMode arg2 ;
20119
20120   arg1 = (Dali::PropertyNotification *)jarg1;
20121   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20122   {
20123     try {
20124       (arg1)->SetNotifyMode(arg2);
20125     } catch (std::out_of_range& e) {
20126       {
20127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20128       };
20129     } catch (std::exception& e) {
20130       {
20131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20132       };
20133     } catch (Dali::DaliException e) {
20134       {
20135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20136       };
20137     } catch (...) {
20138       {
20139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20140       };
20141     }
20142   }
20143
20144 }
20145
20146
20147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20148   int jresult ;
20149   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20150   Dali::PropertyNotification::NotifyMode result;
20151
20152   arg1 = (Dali::PropertyNotification *)jarg1;
20153   {
20154     try {
20155       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20156     } catch (std::out_of_range& e) {
20157       {
20158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20159       };
20160     } catch (std::exception& e) {
20161       {
20162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20163       };
20164     } catch (Dali::DaliException e) {
20165       {
20166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20167       };
20168     } catch (...) {
20169       {
20170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20171       };
20172     }
20173   }
20174
20175   jresult = (int)result;
20176   return jresult;
20177 }
20178
20179
20180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20181   unsigned int jresult ;
20182   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20183   bool result;
20184
20185   arg1 = (Dali::PropertyNotification *)jarg1;
20186   {
20187     try {
20188       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20189     } catch (std::out_of_range& e) {
20190       {
20191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20192       };
20193     } catch (std::exception& e) {
20194       {
20195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20196       };
20197     } catch (Dali::DaliException e) {
20198       {
20199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20200       };
20201     } catch (...) {
20202       {
20203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20204       };
20205     }
20206   }
20207
20208   jresult = result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20214   void * jresult ;
20215   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20216   Dali::PropertyNotifySignalType *result = 0 ;
20217
20218   arg1 = (Dali::PropertyNotification *)jarg1;
20219   {
20220     try {
20221       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20222     } catch (std::out_of_range& e) {
20223       {
20224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20225       };
20226     } catch (std::exception& e) {
20227       {
20228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20229       };
20230     } catch (Dali::DaliException e) {
20231       {
20232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20233       };
20234     } catch (...) {
20235       {
20236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20237       };
20238     }
20239   }
20240
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20247   void * jresult ;
20248   Dali::Handle *result = 0 ;
20249
20250   {
20251     try {
20252       result = (Dali::Handle *)new Dali::Handle();
20253     } catch (std::out_of_range& e) {
20254       {
20255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20256       };
20257     } catch (std::exception& e) {
20258       {
20259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20260       };
20261     } catch (Dali::DaliException e) {
20262       {
20263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20264       };
20265     } catch (...) {
20266       {
20267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20268       };
20269     }
20270   }
20271
20272   jresult = (void *)result;
20273   return jresult;
20274 }
20275
20276
20277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20278   void * jresult ;
20279   Dali::Handle result;
20280
20281   {
20282     try {
20283       result = Dali::Handle::New();
20284     } catch (std::out_of_range& e) {
20285       {
20286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20287       };
20288     } catch (std::exception& e) {
20289       {
20290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20291       };
20292     } catch (Dali::DaliException e) {
20293       {
20294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20295       };
20296     } catch (...) {
20297       {
20298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20299       };
20300     }
20301   }
20302
20303   jresult = new Dali::Handle((const Dali::Handle &)result);
20304   return jresult;
20305 }
20306
20307
20308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20309   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20310
20311   arg1 = (Dali::Handle *)jarg1;
20312   {
20313     try {
20314       delete arg1;
20315     } catch (std::out_of_range& e) {
20316       {
20317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20318       };
20319     } catch (std::exception& e) {
20320       {
20321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20322       };
20323     } catch (Dali::DaliException e) {
20324       {
20325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20326       };
20327     } catch (...) {
20328       {
20329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20330       };
20331     }
20332   }
20333
20334 }
20335
20336
20337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20338   void * jresult ;
20339   Dali::Handle *arg1 = 0 ;
20340   Dali::Handle *result = 0 ;
20341
20342   arg1 = (Dali::Handle *)jarg1;
20343   if (!arg1) {
20344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20345     return 0;
20346   }
20347   {
20348     try {
20349       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20350     } catch (std::out_of_range& e) {
20351       {
20352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20353       };
20354     } catch (std::exception& e) {
20355       {
20356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20357       };
20358     } catch (Dali::DaliException e) {
20359       {
20360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20361       };
20362     } catch (...) {
20363       {
20364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20365       };
20366     }
20367   }
20368
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20375   void * jresult ;
20376   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20377   Dali::Handle *arg2 = 0 ;
20378   Dali::Handle *result = 0 ;
20379
20380   arg1 = (Dali::Handle *)jarg1;
20381   arg2 = (Dali::Handle *)jarg2;
20382   if (!arg2) {
20383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20384     return 0;
20385   }
20386   {
20387     try {
20388       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20389     } catch (std::out_of_range& e) {
20390       {
20391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20392       };
20393     } catch (std::exception& e) {
20394       {
20395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20396       };
20397     } catch (Dali::DaliException e) {
20398       {
20399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20400       };
20401     } catch (...) {
20402       {
20403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20404       };
20405     }
20406   }
20407
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20414   void * jresult ;
20415   Dali::BaseHandle arg1 ;
20416   Dali::BaseHandle *argp1 ;
20417   Dali::Handle result;
20418
20419   argp1 = (Dali::BaseHandle *)jarg1;
20420   if (!argp1) {
20421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20422     return 0;
20423   }
20424   arg1 = *argp1;
20425   {
20426     try {
20427       result = Dali::Handle::DownCast(arg1);
20428     } catch (std::out_of_range& e) {
20429       {
20430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20431       };
20432     } catch (std::exception& e) {
20433       {
20434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20435       };
20436     } catch (Dali::DaliException e) {
20437       {
20438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20439       };
20440     } catch (...) {
20441       {
20442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20443       };
20444     }
20445   }
20446
20447   jresult = new Dali::Handle((const Dali::Handle &)result);
20448   return jresult;
20449 }
20450
20451
20452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20453   unsigned int jresult ;
20454   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20455   Dali::Handle::Capability arg2 ;
20456   bool result;
20457
20458   arg1 = (Dali::Handle *)jarg1;
20459   arg2 = (Dali::Handle::Capability)jarg2;
20460   {
20461     try {
20462       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20463     } catch (std::out_of_range& e) {
20464       {
20465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20466       };
20467     } catch (std::exception& e) {
20468       {
20469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20470       };
20471     } catch (Dali::DaliException e) {
20472       {
20473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20474       };
20475     } catch (...) {
20476       {
20477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20478       };
20479     }
20480   }
20481
20482   jresult = result;
20483   return jresult;
20484 }
20485
20486
20487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20488   unsigned int jresult ;
20489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20490   unsigned int result;
20491
20492   arg1 = (Dali::Handle *)jarg1;
20493   {
20494     try {
20495       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20496     } catch (std::out_of_range& e) {
20497       {
20498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20499       };
20500     } catch (std::exception& e) {
20501       {
20502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20503       };
20504     } catch (Dali::DaliException e) {
20505       {
20506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20507       };
20508     } catch (...) {
20509       {
20510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20511       };
20512     }
20513   }
20514
20515   jresult = result;
20516   return jresult;
20517 }
20518
20519
20520 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20521   char * jresult ;
20522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20523   Dali::Property::Index arg2 ;
20524   std::string result;
20525
20526   arg1 = (Dali::Handle *)jarg1;
20527   arg2 = (Dali::Property::Index)jarg2;
20528   {
20529     try {
20530       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20531     } catch (std::out_of_range& e) {
20532       {
20533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20534       };
20535     } catch (std::exception& e) {
20536       {
20537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20538       };
20539     } catch (Dali::DaliException e) {
20540       {
20541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20542       };
20543     } catch (...) {
20544       {
20545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20546       };
20547     }
20548   }
20549
20550   jresult = SWIG_csharp_string_callback((&result)->c_str());
20551   return jresult;
20552 }
20553
20554
20555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20556   int jresult ;
20557   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20558   std::string *arg2 = 0 ;
20559   Dali::Property::Index result;
20560
20561   arg1 = (Dali::Handle *)jarg1;
20562   if (!jarg2) {
20563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20564     return 0;
20565   }
20566   std::string arg2_str(jarg2);
20567   arg2 = &arg2_str;
20568   {
20569     try {
20570       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20571     } catch (std::out_of_range& e) {
20572       {
20573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20574       };
20575     } catch (std::exception& e) {
20576       {
20577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20578       };
20579     } catch (Dali::DaliException e) {
20580       {
20581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20582       };
20583     } catch (...) {
20584       {
20585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20586       };
20587     }
20588   }
20589
20590   jresult = result;
20591
20592   //argout typemap for const std::string&
20593
20594   return jresult;
20595 }
20596
20597
20598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20599   unsigned int jresult ;
20600   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20601   Dali::Property::Index arg2 ;
20602   bool result;
20603
20604   arg1 = (Dali::Handle *)jarg1;
20605   arg2 = (Dali::Property::Index)jarg2;
20606   {
20607     try {
20608       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20609     } catch (std::out_of_range& e) {
20610       {
20611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20612       };
20613     } catch (std::exception& e) {
20614       {
20615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20616       };
20617     } catch (Dali::DaliException e) {
20618       {
20619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20620       };
20621     } catch (...) {
20622       {
20623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20624       };
20625     }
20626   }
20627
20628   jresult = result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20634   unsigned int jresult ;
20635   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20636   Dali::Property::Index arg2 ;
20637   bool result;
20638
20639   arg1 = (Dali::Handle *)jarg1;
20640   arg2 = (Dali::Property::Index)jarg2;
20641   {
20642     try {
20643       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20644     } catch (std::out_of_range& e) {
20645       {
20646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20647       };
20648     } catch (std::exception& e) {
20649       {
20650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20651       };
20652     } catch (Dali::DaliException e) {
20653       {
20654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20655       };
20656     } catch (...) {
20657       {
20658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20659       };
20660     }
20661   }
20662
20663   jresult = result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20669   unsigned int jresult ;
20670   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20671   Dali::Property::Index arg2 ;
20672   bool result;
20673
20674   arg1 = (Dali::Handle *)jarg1;
20675   arg2 = (Dali::Property::Index)jarg2;
20676   {
20677     try {
20678       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20679     } catch (std::out_of_range& e) {
20680       {
20681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20682       };
20683     } catch (std::exception& e) {
20684       {
20685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20686       };
20687     } catch (Dali::DaliException e) {
20688       {
20689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20690       };
20691     } catch (...) {
20692       {
20693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20694       };
20695     }
20696   }
20697
20698   jresult = result;
20699   return jresult;
20700 }
20701
20702
20703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20704   int jresult ;
20705   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20706   Dali::Property::Index arg2 ;
20707   Dali::Property::Type result;
20708
20709   arg1 = (Dali::Handle *)jarg1;
20710   arg2 = (Dali::Property::Index)jarg2;
20711   {
20712     try {
20713       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20714     } catch (std::out_of_range& e) {
20715       {
20716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20717       };
20718     } catch (std::exception& e) {
20719       {
20720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20721       };
20722     } catch (Dali::DaliException e) {
20723       {
20724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20725       };
20726     } catch (...) {
20727       {
20728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20729       };
20730     }
20731   }
20732
20733   jresult = (int)result;
20734   return jresult;
20735 }
20736
20737
20738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20739   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20740   Dali::Property::Index arg2 ;
20741   Dali::Property::Value *arg3 = 0 ;
20742
20743   arg1 = (Dali::Handle *)jarg1;
20744   arg2 = (Dali::Property::Index)jarg2;
20745   arg3 = (Dali::Property::Value *)jarg3;
20746   if (!arg3) {
20747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20748     return ;
20749   }
20750   {
20751     try {
20752       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20753     } catch (std::out_of_range& e) {
20754       {
20755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20756       };
20757     } catch (std::exception& e) {
20758       {
20759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20760       };
20761     } catch (Dali::DaliException e) {
20762       {
20763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20764       };
20765     } catch (...) {
20766       {
20767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20768       };
20769     }
20770   }
20771
20772 }
20773
20774
20775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20776   int jresult ;
20777   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20778   std::string *arg2 = 0 ;
20779   Dali::Property::Value *arg3 = 0 ;
20780   Dali::Property::Index result;
20781
20782   arg1 = (Dali::Handle *)jarg1;
20783   if (!jarg2) {
20784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20785     return 0;
20786   }
20787   std::string arg2_str(jarg2);
20788   arg2 = &arg2_str;
20789   arg3 = (Dali::Property::Value *)jarg3;
20790   if (!arg3) {
20791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20792     return 0;
20793   }
20794   {
20795     try {
20796       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20797     } catch (std::out_of_range& e) {
20798       {
20799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20800       };
20801     } catch (std::exception& e) {
20802       {
20803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20804       };
20805     } catch (Dali::DaliException e) {
20806       {
20807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20808       };
20809     } catch (...) {
20810       {
20811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20812       };
20813     }
20814   }
20815
20816   jresult = result;
20817
20818   //argout typemap for const std::string&
20819
20820   return jresult;
20821 }
20822
20823
20824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20825   int jresult ;
20826   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20827   std::string *arg2 = 0 ;
20828   Dali::Property::Value *arg3 = 0 ;
20829   Dali::Property::AccessMode arg4 ;
20830   Dali::Property::Index result;
20831
20832   arg1 = (Dali::Handle *)jarg1;
20833   if (!jarg2) {
20834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20835     return 0;
20836   }
20837   std::string arg2_str(jarg2);
20838   arg2 = &arg2_str;
20839   arg3 = (Dali::Property::Value *)jarg3;
20840   if (!arg3) {
20841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20842     return 0;
20843   }
20844   arg4 = (Dali::Property::AccessMode)jarg4;
20845   {
20846     try {
20847       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20848     } catch (std::out_of_range& e) {
20849       {
20850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20851       };
20852     } catch (std::exception& e) {
20853       {
20854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20855       };
20856     } catch (Dali::DaliException e) {
20857       {
20858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20859       };
20860     } catch (...) {
20861       {
20862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20863       };
20864     }
20865   }
20866
20867   jresult = result;
20868
20869   //argout typemap for const std::string&
20870
20871   return jresult;
20872 }
20873
20874
20875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20876   void * jresult ;
20877   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20878   Dali::Property::Index arg2 ;
20879   Dali::Property::Value result;
20880
20881   arg1 = (Dali::Handle *)jarg1;
20882   arg2 = (Dali::Property::Index)jarg2;
20883   {
20884     try {
20885       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20886     } catch (std::out_of_range& e) {
20887       {
20888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20889       };
20890     } catch (std::exception& e) {
20891       {
20892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20893       };
20894     } catch (Dali::DaliException e) {
20895       {
20896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20897       };
20898     } catch (...) {
20899       {
20900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20901       };
20902     }
20903   }
20904
20905   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20906   return jresult;
20907 }
20908
20909
20910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20911   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20912   Dali::Property::IndexContainer *arg2 = 0 ;
20913
20914   arg1 = (Dali::Handle *)jarg1;
20915   arg2 = (Dali::Property::IndexContainer *)jarg2;
20916   if (!arg2) {
20917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20918     return ;
20919   }
20920   {
20921     try {
20922       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20930       };
20931     } catch (Dali::DaliException e) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20934       };
20935     } catch (...) {
20936       {
20937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20938       };
20939     }
20940   }
20941
20942 }
20943
20944
20945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20946   void * jresult ;
20947   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20948   Dali::Property::Index arg2 ;
20949   Dali::PropertyCondition *arg3 = 0 ;
20950   Dali::PropertyNotification result;
20951
20952   arg1 = (Dali::Handle *)jarg1;
20953   arg2 = (Dali::Property::Index)jarg2;
20954   arg3 = (Dali::PropertyCondition *)jarg3;
20955   if (!arg3) {
20956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20957     return 0;
20958   }
20959   {
20960     try {
20961       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20962     } catch (std::out_of_range& e) {
20963       {
20964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20965       };
20966     } catch (std::exception& e) {
20967       {
20968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20969       };
20970     } catch (Dali::DaliException e) {
20971       {
20972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20973       };
20974     } catch (...) {
20975       {
20976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20977       };
20978     }
20979   }
20980
20981   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20982   return jresult;
20983 }
20984
20985
20986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20987   void * jresult ;
20988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20989   Dali::Property::Index arg2 ;
20990   int arg3 ;
20991   Dali::PropertyCondition *arg4 = 0 ;
20992   Dali::PropertyNotification result;
20993
20994   arg1 = (Dali::Handle *)jarg1;
20995   arg2 = (Dali::Property::Index)jarg2;
20996   arg3 = (int)jarg3;
20997   arg4 = (Dali::PropertyCondition *)jarg4;
20998   if (!arg4) {
20999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21000     return 0;
21001   }
21002   {
21003     try {
21004       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21005     } catch (std::out_of_range& e) {
21006       {
21007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21008       };
21009     } catch (std::exception& e) {
21010       {
21011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21012       };
21013     } catch (Dali::DaliException e) {
21014       {
21015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21016       };
21017     } catch (...) {
21018       {
21019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21020       };
21021     }
21022   }
21023
21024   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21025   return jresult;
21026 }
21027
21028
21029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21030   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21031   Dali::PropertyNotification arg2 ;
21032   Dali::PropertyNotification *argp2 ;
21033
21034   arg1 = (Dali::Handle *)jarg1;
21035   argp2 = (Dali::PropertyNotification *)jarg2;
21036   if (!argp2) {
21037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21038     return ;
21039   }
21040   arg2 = *argp2;
21041   {
21042     try {
21043       (arg1)->RemovePropertyNotification(arg2);
21044     } catch (std::out_of_range& e) {
21045       {
21046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21047       };
21048     } catch (std::exception& e) {
21049       {
21050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21051       };
21052     } catch (Dali::DaliException e) {
21053       {
21054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21055       };
21056     } catch (...) {
21057       {
21058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21059       };
21060     }
21061   }
21062
21063 }
21064
21065
21066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21067   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21068
21069   arg1 = (Dali::Handle *)jarg1;
21070   {
21071     try {
21072       (arg1)->RemovePropertyNotifications();
21073     } catch (std::out_of_range& e) {
21074       {
21075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21076       };
21077     } catch (std::exception& e) {
21078       {
21079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21080       };
21081     } catch (Dali::DaliException e) {
21082       {
21083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21084       };
21085     } catch (...) {
21086       {
21087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21088       };
21089     }
21090   }
21091
21092 }
21093
21094
21095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21096   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21097
21098   arg1 = (Dali::Handle *)jarg1;
21099   {
21100     try {
21101       (arg1)->RemoveConstraints();
21102     } catch (std::out_of_range& e) {
21103       {
21104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (std::exception& e) {
21107       {
21108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21109       };
21110     } catch (Dali::DaliException e) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21113       };
21114     } catch (...) {
21115       {
21116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21117       };
21118     }
21119   }
21120
21121 }
21122
21123
21124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21125   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21126   unsigned int arg2 ;
21127
21128   arg1 = (Dali::Handle *)jarg1;
21129   arg2 = (unsigned int)jarg2;
21130   {
21131     try {
21132       (arg1)->RemoveConstraints(arg2);
21133     } catch (std::out_of_range& e) {
21134       {
21135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21136       };
21137     } catch (std::exception& e) {
21138       {
21139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21140       };
21141     } catch (Dali::DaliException e) {
21142       {
21143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21144       };
21145     } catch (...) {
21146       {
21147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21148       };
21149     }
21150   }
21151
21152 }
21153
21154
21155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21156   int jresult ;
21157   Dali::Property::Index result;
21158
21159   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21160   jresult = result;
21161   return jresult;
21162 }
21163
21164
21165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21166   void * jresult ;
21167   Dali::Handle result;
21168
21169   {
21170     try {
21171       result = Dali::WeightObject::New();
21172     } catch (std::out_of_range& e) {
21173       {
21174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21175       };
21176     } catch (std::exception& e) {
21177       {
21178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21179       };
21180     } catch (Dali::DaliException e) {
21181       {
21182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21183       };
21184     } catch (...) {
21185       {
21186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21187       };
21188     }
21189   }
21190
21191   jresult = new Dali::Handle((const Dali::Handle &)result);
21192   return jresult;
21193 }
21194
21195
21196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21197   void * jresult ;
21198   Dali::TypeInfo *result = 0 ;
21199
21200   {
21201     try {
21202       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21203     } catch (std::out_of_range& e) {
21204       {
21205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21206       };
21207     } catch (std::exception& e) {
21208       {
21209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21210       };
21211     } catch (Dali::DaliException e) {
21212       {
21213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21214       };
21215     } catch (...) {
21216       {
21217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21218       };
21219     }
21220   }
21221
21222   jresult = (void *)result;
21223   return jresult;
21224 }
21225
21226
21227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21228   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21229
21230   arg1 = (Dali::TypeInfo *)jarg1;
21231   {
21232     try {
21233       delete arg1;
21234     } catch (std::out_of_range& e) {
21235       {
21236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21237       };
21238     } catch (std::exception& e) {
21239       {
21240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21241       };
21242     } catch (Dali::DaliException e) {
21243       {
21244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21245       };
21246     } catch (...) {
21247       {
21248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21249       };
21250     }
21251   }
21252
21253 }
21254
21255
21256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21257   void * jresult ;
21258   Dali::TypeInfo *arg1 = 0 ;
21259   Dali::TypeInfo *result = 0 ;
21260
21261   arg1 = (Dali::TypeInfo *)jarg1;
21262   if (!arg1) {
21263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21264     return 0;
21265   }
21266   {
21267     try {
21268       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21269     } catch (std::out_of_range& e) {
21270       {
21271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21272       };
21273     } catch (std::exception& e) {
21274       {
21275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21276       };
21277     } catch (Dali::DaliException e) {
21278       {
21279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21280       };
21281     } catch (...) {
21282       {
21283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21284       };
21285     }
21286   }
21287
21288   jresult = (void *)result;
21289   return jresult;
21290 }
21291
21292
21293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21294   void * jresult ;
21295   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21296   Dali::TypeInfo *arg2 = 0 ;
21297   Dali::TypeInfo *result = 0 ;
21298
21299   arg1 = (Dali::TypeInfo *)jarg1;
21300   arg2 = (Dali::TypeInfo *)jarg2;
21301   if (!arg2) {
21302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21303     return 0;
21304   }
21305   {
21306     try {
21307       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21308     } catch (std::out_of_range& e) {
21309       {
21310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21311       };
21312     } catch (std::exception& e) {
21313       {
21314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21315       };
21316     } catch (Dali::DaliException e) {
21317       {
21318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21319       };
21320     } catch (...) {
21321       {
21322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21323       };
21324     }
21325   }
21326
21327   jresult = (void *)result;
21328   return jresult;
21329 }
21330
21331
21332 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21333   char * jresult ;
21334   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21335   std::string *result = 0 ;
21336
21337   arg1 = (Dali::TypeInfo *)jarg1;
21338   {
21339     try {
21340       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21341     } catch (std::out_of_range& e) {
21342       {
21343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21344       };
21345     } catch (std::exception& e) {
21346       {
21347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21348       };
21349     } catch (Dali::DaliException e) {
21350       {
21351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21352       };
21353     } catch (...) {
21354       {
21355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21356       };
21357     }
21358   }
21359
21360   jresult = SWIG_csharp_string_callback(result->c_str());
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21366   char * jresult ;
21367   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21368   std::string *result = 0 ;
21369
21370   arg1 = (Dali::TypeInfo *)jarg1;
21371   {
21372     try {
21373       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21374     } catch (std::out_of_range& e) {
21375       {
21376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (std::exception& e) {
21379       {
21380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21381       };
21382     } catch (Dali::DaliException e) {
21383       {
21384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21385       };
21386     } catch (...) {
21387       {
21388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21389       };
21390     }
21391   }
21392
21393   jresult = SWIG_csharp_string_callback(result->c_str());
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21399   void * jresult ;
21400   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21401   Dali::BaseHandle result;
21402
21403   arg1 = (Dali::TypeInfo *)jarg1;
21404   {
21405     try {
21406       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21407     } catch (std::out_of_range& e) {
21408       {
21409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21410       };
21411     } catch (std::exception& e) {
21412       {
21413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21414       };
21415     } catch (Dali::DaliException e) {
21416       {
21417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21418       };
21419     } catch (...) {
21420       {
21421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21422       };
21423     }
21424   }
21425
21426   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21427   return jresult;
21428 }
21429
21430
21431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21432   unsigned long jresult ;
21433   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21434   size_t result;
21435
21436   arg1 = (Dali::TypeInfo *)jarg1;
21437   {
21438     try {
21439       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21440     } catch (std::out_of_range& e) {
21441       {
21442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21443       };
21444     } catch (std::exception& e) {
21445       {
21446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21447       };
21448     } catch (Dali::DaliException e) {
21449       {
21450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21451       };
21452     } catch (...) {
21453       {
21454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21455       };
21456     }
21457   }
21458
21459   jresult = (unsigned long)result;
21460   return jresult;
21461 }
21462
21463
21464 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21465   char * jresult ;
21466   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21467   size_t arg2 ;
21468   std::string result;
21469
21470   arg1 = (Dali::TypeInfo *)jarg1;
21471   arg2 = (size_t)jarg2;
21472   {
21473     try {
21474       result = (arg1)->GetActionName(arg2);
21475     } catch (std::out_of_range& e) {
21476       {
21477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21478       };
21479     } catch (std::exception& e) {
21480       {
21481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21482       };
21483     } catch (Dali::DaliException e) {
21484       {
21485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21486       };
21487     } catch (...) {
21488       {
21489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21490       };
21491     }
21492   }
21493
21494   jresult = SWIG_csharp_string_callback((&result)->c_str());
21495   return jresult;
21496 }
21497
21498
21499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21500   unsigned long jresult ;
21501   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21502   size_t result;
21503
21504   arg1 = (Dali::TypeInfo *)jarg1;
21505   {
21506     try {
21507       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21508     } catch (std::out_of_range& e) {
21509       {
21510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21511       };
21512     } catch (std::exception& e) {
21513       {
21514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21515       };
21516     } catch (Dali::DaliException e) {
21517       {
21518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21519       };
21520     } catch (...) {
21521       {
21522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21523       };
21524     }
21525   }
21526
21527   jresult = (unsigned long)result;
21528   return jresult;
21529 }
21530
21531
21532 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21533   char * jresult ;
21534   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21535   size_t arg2 ;
21536   std::string result;
21537
21538   arg1 = (Dali::TypeInfo *)jarg1;
21539   arg2 = (size_t)jarg2;
21540   {
21541     try {
21542       result = (arg1)->GetSignalName(arg2);
21543     } catch (std::out_of_range& e) {
21544       {
21545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21546       };
21547     } catch (std::exception& e) {
21548       {
21549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (Dali::DaliException e) {
21552       {
21553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21554       };
21555     } catch (...) {
21556       {
21557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21558       };
21559     }
21560   }
21561
21562   jresult = SWIG_csharp_string_callback((&result)->c_str());
21563   return jresult;
21564 }
21565
21566
21567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21568   unsigned long jresult ;
21569   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21570   size_t result;
21571
21572   arg1 = (Dali::TypeInfo *)jarg1;
21573   {
21574     try {
21575       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21576     } catch (std::out_of_range& e) {
21577       {
21578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21579       };
21580     } catch (std::exception& e) {
21581       {
21582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21583       };
21584     } catch (Dali::DaliException e) {
21585       {
21586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21587       };
21588     } catch (...) {
21589       {
21590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21591       };
21592     }
21593   }
21594
21595   jresult = (unsigned long)result;
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21601   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21602   Dali::Property::IndexContainer *arg2 = 0 ;
21603
21604   arg1 = (Dali::TypeInfo *)jarg1;
21605   arg2 = (Dali::Property::IndexContainer *)jarg2;
21606   if (!arg2) {
21607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21608     return ;
21609   }
21610   {
21611     try {
21612       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21613     } catch (std::out_of_range& e) {
21614       {
21615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21616       };
21617     } catch (std::exception& e) {
21618       {
21619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21620       };
21621     } catch (Dali::DaliException e) {
21622       {
21623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21624       };
21625     } catch (...) {
21626       {
21627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21628       };
21629     }
21630   }
21631
21632 }
21633
21634
21635 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21636   char * jresult ;
21637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21638   Dali::Property::Index arg2 ;
21639   std::string *result = 0 ;
21640
21641   arg1 = (Dali::TypeInfo *)jarg1;
21642   arg2 = (Dali::Property::Index)jarg2;
21643   {
21644     try {
21645       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21646     } catch (std::out_of_range& e) {
21647       {
21648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21649       };
21650     } catch (std::exception& e) {
21651       {
21652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21653       };
21654     } catch (Dali::DaliException e) {
21655       {
21656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21657       };
21658     } catch (...) {
21659       {
21660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21661       };
21662     }
21663   }
21664
21665   jresult = SWIG_csharp_string_callback(result->c_str());
21666   return jresult;
21667 }
21668
21669
21670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21671   void * jresult ;
21672   Dali::TypeRegistry result;
21673
21674   {
21675     try {
21676       result = Dali::TypeRegistry::Get();
21677     } catch (std::out_of_range& e) {
21678       {
21679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21680       };
21681     } catch (std::exception& e) {
21682       {
21683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21684       };
21685     } catch (Dali::DaliException e) {
21686       {
21687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21688       };
21689     } catch (...) {
21690       {
21691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21692       };
21693     }
21694   }
21695
21696   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21697   return jresult;
21698 }
21699
21700
21701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21702   void * jresult ;
21703   Dali::TypeRegistry *result = 0 ;
21704
21705   {
21706     try {
21707       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21708     } catch (std::out_of_range& e) {
21709       {
21710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21711       };
21712     } catch (std::exception& e) {
21713       {
21714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21715       };
21716     } catch (Dali::DaliException e) {
21717       {
21718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21719       };
21720     } catch (...) {
21721       {
21722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21723       };
21724     }
21725   }
21726
21727   jresult = (void *)result;
21728   return jresult;
21729 }
21730
21731
21732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21733   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21734
21735   arg1 = (Dali::TypeRegistry *)jarg1;
21736   {
21737     try {
21738       delete arg1;
21739     } catch (std::out_of_range& e) {
21740       {
21741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21742       };
21743     } catch (std::exception& e) {
21744       {
21745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21746       };
21747     } catch (Dali::DaliException e) {
21748       {
21749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21750       };
21751     } catch (...) {
21752       {
21753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21754       };
21755     }
21756   }
21757
21758 }
21759
21760
21761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21762   void * jresult ;
21763   Dali::TypeRegistry *arg1 = 0 ;
21764   Dali::TypeRegistry *result = 0 ;
21765
21766   arg1 = (Dali::TypeRegistry *)jarg1;
21767   if (!arg1) {
21768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21769     return 0;
21770   }
21771   {
21772     try {
21773       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21774     } catch (std::out_of_range& e) {
21775       {
21776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (std::exception& e) {
21779       {
21780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21781       };
21782     } catch (Dali::DaliException e) {
21783       {
21784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21785       };
21786     } catch (...) {
21787       {
21788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21789       };
21790     }
21791   }
21792
21793   jresult = (void *)result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21799   void * jresult ;
21800   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21801   Dali::TypeRegistry *arg2 = 0 ;
21802   Dali::TypeRegistry *result = 0 ;
21803
21804   arg1 = (Dali::TypeRegistry *)jarg1;
21805   arg2 = (Dali::TypeRegistry *)jarg2;
21806   if (!arg2) {
21807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21808     return 0;
21809   }
21810   {
21811     try {
21812       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21813     } catch (std::out_of_range& e) {
21814       {
21815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21816       };
21817     } catch (std::exception& e) {
21818       {
21819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21820       };
21821     } catch (Dali::DaliException e) {
21822       {
21823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21824       };
21825     } catch (...) {
21826       {
21827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21828       };
21829     }
21830   }
21831
21832   jresult = (void *)result;
21833   return jresult;
21834 }
21835
21836
21837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21838   void * jresult ;
21839   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21840   std::string *arg2 = 0 ;
21841   Dali::TypeInfo result;
21842
21843   arg1 = (Dali::TypeRegistry *)jarg1;
21844   if (!jarg2) {
21845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21846     return 0;
21847   }
21848   std::string arg2_str(jarg2);
21849   arg2 = &arg2_str;
21850   {
21851     try {
21852       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (Dali::DaliException e) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21864       };
21865     } catch (...) {
21866       {
21867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21868       };
21869     }
21870   }
21871
21872   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21873
21874   //argout typemap for const std::string&
21875
21876   return jresult;
21877 }
21878
21879
21880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21881   void * jresult ;
21882   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21883   std::type_info *arg2 = 0 ;
21884   Dali::TypeInfo result;
21885
21886   arg1 = (Dali::TypeRegistry *)jarg1;
21887   arg2 = (std::type_info *)jarg2;
21888   if (!arg2) {
21889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21890     return 0;
21891   }
21892   {
21893     try {
21894       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21895     } catch (std::out_of_range& e) {
21896       {
21897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21898       };
21899     } catch (std::exception& e) {
21900       {
21901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21902       };
21903     } catch (Dali::DaliException e) {
21904       {
21905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21906       };
21907     } catch (...) {
21908       {
21909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21910       };
21911     }
21912   }
21913
21914   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21915   return jresult;
21916 }
21917
21918
21919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21920   unsigned long jresult ;
21921   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21922   size_t result;
21923
21924   arg1 = (Dali::TypeRegistry *)jarg1;
21925   {
21926     try {
21927       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21928     } catch (std::out_of_range& e) {
21929       {
21930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21931       };
21932     } catch (std::exception& e) {
21933       {
21934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21935       };
21936     } catch (Dali::DaliException e) {
21937       {
21938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21943       };
21944     }
21945   }
21946
21947   jresult = (unsigned long)result;
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21953   char * jresult ;
21954   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21955   size_t arg2 ;
21956   std::string result;
21957
21958   arg1 = (Dali::TypeRegistry *)jarg1;
21959   arg2 = (size_t)jarg2;
21960   {
21961     try {
21962       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21963     } catch (std::out_of_range& e) {
21964       {
21965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21966       };
21967     } catch (std::exception& e) {
21968       {
21969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21970       };
21971     } catch (Dali::DaliException e) {
21972       {
21973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21974       };
21975     } catch (...) {
21976       {
21977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21978       };
21979     }
21980   }
21981
21982   jresult = SWIG_csharp_string_callback((&result)->c_str());
21983   return jresult;
21984 }
21985
21986
21987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21988   void * jresult ;
21989   std::type_info *arg1 = 0 ;
21990   std::type_info *arg2 = 0 ;
21991   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21992   Dali::TypeRegistration *result = 0 ;
21993
21994   arg1 = (std::type_info *)jarg1;
21995   if (!arg1) {
21996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21997     return 0;
21998   }
21999   arg2 = (std::type_info *)jarg2;
22000   if (!arg2) {
22001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22002     return 0;
22003   }
22004   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22005   {
22006     try {
22007       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22008     } catch (std::out_of_range& e) {
22009       {
22010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22011       };
22012     } catch (std::exception& e) {
22013       {
22014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (Dali::DaliException e) {
22017       {
22018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22019       };
22020     } catch (...) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22023       };
22024     }
22025   }
22026
22027   jresult = (void *)result;
22028   return jresult;
22029 }
22030
22031
22032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22033   void * jresult ;
22034   std::type_info *arg1 = 0 ;
22035   std::type_info *arg2 = 0 ;
22036   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22037   bool arg4 ;
22038   Dali::TypeRegistration *result = 0 ;
22039
22040   arg1 = (std::type_info *)jarg1;
22041   if (!arg1) {
22042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22043     return 0;
22044   }
22045   arg2 = (std::type_info *)jarg2;
22046   if (!arg2) {
22047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22048     return 0;
22049   }
22050   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22051   arg4 = jarg4 ? true : false;
22052   {
22053     try {
22054       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22055     } catch (std::out_of_range& e) {
22056       {
22057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22058       };
22059     } catch (std::exception& e) {
22060       {
22061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22062       };
22063     } catch (Dali::DaliException e) {
22064       {
22065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22066       };
22067     } catch (...) {
22068       {
22069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22070       };
22071     }
22072   }
22073
22074   jresult = (void *)result;
22075   return jresult;
22076 }
22077
22078
22079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22080   void * jresult ;
22081   std::string *arg1 = 0 ;
22082   std::type_info *arg2 = 0 ;
22083   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22084   Dali::TypeRegistration *result = 0 ;
22085
22086   if (!jarg1) {
22087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22088     return 0;
22089   }
22090   std::string arg1_str(jarg1);
22091   arg1 = &arg1_str;
22092   arg2 = (std::type_info *)jarg2;
22093   if (!arg2) {
22094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22095     return 0;
22096   }
22097   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22098   {
22099     try {
22100       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22101     } catch (std::out_of_range& e) {
22102       {
22103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22104       };
22105     } catch (std::exception& e) {
22106       {
22107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22108       };
22109     } catch (Dali::DaliException e) {
22110       {
22111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22112       };
22113     } catch (...) {
22114       {
22115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22116       };
22117     }
22118   }
22119
22120   jresult = (void *)result;
22121
22122   //argout typemap for const std::string&
22123
22124   return jresult;
22125 }
22126
22127
22128 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22129   char * jresult ;
22130   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22131   std::string result;
22132
22133   arg1 = (Dali::TypeRegistration *)jarg1;
22134   {
22135     try {
22136       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22137     } catch (std::out_of_range& e) {
22138       {
22139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22140       };
22141     } catch (std::exception& e) {
22142       {
22143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (Dali::DaliException e) {
22146       {
22147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155
22156   jresult = SWIG_csharp_string_callback((&result)->c_str());
22157   return jresult;
22158 }
22159
22160
22161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22162   std::string *arg1 = 0 ;
22163   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22164
22165   if (!jarg1) {
22166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22167     return ;
22168   }
22169   std::string arg1_str(jarg1);
22170   arg1 = &arg1_str;
22171   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22172   {
22173     try {
22174       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22175     } catch (std::out_of_range& e) {
22176       {
22177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22178       };
22179     } catch (std::exception& e) {
22180       {
22181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22182       };
22183     } catch (Dali::DaliException e) {
22184       {
22185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22186       };
22187     } catch (...) {
22188       {
22189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22190       };
22191     }
22192   }
22193
22194
22195   //argout typemap for const std::string&
22196
22197 }
22198
22199
22200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22201   std::string *arg1 = 0 ;
22202   std::string *arg2 = 0 ;
22203   int arg3 ;
22204   Dali::Property::Type arg4 ;
22205   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22206   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22207
22208   if (!jarg1) {
22209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22210     return ;
22211   }
22212   std::string arg1_str(jarg1);
22213   arg1 = &arg1_str;
22214   if (!jarg2) {
22215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22216     return ;
22217   }
22218   std::string arg2_str(jarg2);
22219   arg2 = &arg2_str;
22220   arg3 = (int)jarg3;
22221   arg4 = (Dali::Property::Type)jarg4;
22222   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22223   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22224   {
22225     try {
22226       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22227     } catch (std::out_of_range& e) {
22228       {
22229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22230       };
22231     } catch (std::exception& e) {
22232       {
22233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22234       };
22235     } catch (Dali::DaliException e) {
22236       {
22237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22242       };
22243     }
22244   }
22245
22246
22247   //argout typemap for const std::string&
22248
22249
22250   //argout typemap for const std::string&
22251
22252 }
22253
22254
22255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22256   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22257
22258   arg1 = (Dali::TypeRegistration *)jarg1;
22259   {
22260     try {
22261       delete arg1;
22262     } catch (std::out_of_range& e) {
22263       {
22264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22265       };
22266     } catch (std::exception& e) {
22267       {
22268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22269       };
22270     } catch (Dali::DaliException e) {
22271       {
22272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22273       };
22274     } catch (...) {
22275       {
22276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22277       };
22278     }
22279   }
22280
22281 }
22282
22283
22284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22285   void * jresult ;
22286   Dali::TypeRegistration *arg1 = 0 ;
22287   std::string *arg2 = 0 ;
22288   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22289   Dali::SignalConnectorType *result = 0 ;
22290
22291   arg1 = (Dali::TypeRegistration *)jarg1;
22292   if (!arg1) {
22293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22294     return 0;
22295   }
22296   if (!jarg2) {
22297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22298     return 0;
22299   }
22300   std::string arg2_str(jarg2);
22301   arg2 = &arg2_str;
22302   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22303   {
22304     try {
22305       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22306     } catch (std::out_of_range& e) {
22307       {
22308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22309       };
22310     } catch (std::exception& e) {
22311       {
22312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (Dali::DaliException e) {
22315       {
22316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22321       };
22322     }
22323   }
22324
22325   jresult = (void *)result;
22326
22327   //argout typemap for const std::string&
22328
22329   return jresult;
22330 }
22331
22332
22333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22334   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22335
22336   arg1 = (Dali::SignalConnectorType *)jarg1;
22337   {
22338     try {
22339       delete arg1;
22340     } catch (std::out_of_range& e) {
22341       {
22342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22343       };
22344     } catch (std::exception& e) {
22345       {
22346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22347       };
22348     } catch (Dali::DaliException e) {
22349       {
22350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22351       };
22352     } catch (...) {
22353       {
22354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22355       };
22356     }
22357   }
22358
22359 }
22360
22361
22362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22363   void * jresult ;
22364   Dali::TypeRegistration *arg1 = 0 ;
22365   std::string *arg2 = 0 ;
22366   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22367   Dali::TypeAction *result = 0 ;
22368
22369   arg1 = (Dali::TypeRegistration *)jarg1;
22370   if (!arg1) {
22371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22372     return 0;
22373   }
22374   if (!jarg2) {
22375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22376     return 0;
22377   }
22378   std::string arg2_str(jarg2);
22379   arg2 = &arg2_str;
22380   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22381   {
22382     try {
22383       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22384     } catch (std::out_of_range& e) {
22385       {
22386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22387       };
22388     } catch (std::exception& e) {
22389       {
22390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22391       };
22392     } catch (Dali::DaliException e) {
22393       {
22394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22395       };
22396     } catch (...) {
22397       {
22398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22399       };
22400     }
22401   }
22402
22403   jresult = (void *)result;
22404
22405   //argout typemap for const std::string&
22406
22407   return jresult;
22408 }
22409
22410
22411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22412   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22413
22414   arg1 = (Dali::TypeAction *)jarg1;
22415   {
22416     try {
22417       delete arg1;
22418     } catch (std::out_of_range& e) {
22419       {
22420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22421       };
22422     } catch (std::exception& e) {
22423       {
22424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22425       };
22426     } catch (Dali::DaliException e) {
22427       {
22428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22429       };
22430     } catch (...) {
22431       {
22432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22433       };
22434     }
22435   }
22436
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22441   void * jresult ;
22442   Dali::TypeRegistration *arg1 = 0 ;
22443   std::string *arg2 = 0 ;
22444   Dali::Property::Index arg3 ;
22445   Dali::Property::Type arg4 ;
22446   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22447   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22448   Dali::PropertyRegistration *result = 0 ;
22449
22450   arg1 = (Dali::TypeRegistration *)jarg1;
22451   if (!arg1) {
22452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22453     return 0;
22454   }
22455   if (!jarg2) {
22456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22457     return 0;
22458   }
22459   std::string arg2_str(jarg2);
22460   arg2 = &arg2_str;
22461   arg3 = (Dali::Property::Index)jarg3;
22462   arg4 = (Dali::Property::Type)jarg4;
22463   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22464   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22465   {
22466     try {
22467       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22468     } catch (std::out_of_range& e) {
22469       {
22470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22471       };
22472     } catch (std::exception& e) {
22473       {
22474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22475       };
22476     } catch (Dali::DaliException e) {
22477       {
22478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22479       };
22480     } catch (...) {
22481       {
22482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22483       };
22484     }
22485   }
22486
22487   jresult = (void *)result;
22488
22489   //argout typemap for const std::string&
22490
22491   return jresult;
22492 }
22493
22494
22495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22496   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22497
22498   arg1 = (Dali::PropertyRegistration *)jarg1;
22499   {
22500     try {
22501       delete arg1;
22502     } catch (std::out_of_range& e) {
22503       {
22504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22505       };
22506     } catch (std::exception& e) {
22507       {
22508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22509       };
22510     } catch (Dali::DaliException e) {
22511       {
22512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22513       };
22514     } catch (...) {
22515       {
22516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22517       };
22518     }
22519   }
22520
22521 }
22522
22523
22524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22525   void * jresult ;
22526   Dali::TypeRegistration *arg1 = 0 ;
22527   std::string *arg2 = 0 ;
22528   Dali::Property::Index arg3 ;
22529   Dali::Property::Type arg4 ;
22530   Dali::AnimatablePropertyRegistration *result = 0 ;
22531
22532   arg1 = (Dali::TypeRegistration *)jarg1;
22533   if (!arg1) {
22534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22535     return 0;
22536   }
22537   if (!jarg2) {
22538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22539     return 0;
22540   }
22541   std::string arg2_str(jarg2);
22542   arg2 = &arg2_str;
22543   arg3 = (Dali::Property::Index)jarg3;
22544   arg4 = (Dali::Property::Type)jarg4;
22545   {
22546     try {
22547       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22548     } catch (std::out_of_range& e) {
22549       {
22550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22551       };
22552     } catch (std::exception& e) {
22553       {
22554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22555       };
22556     } catch (Dali::DaliException e) {
22557       {
22558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22559       };
22560     } catch (...) {
22561       {
22562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22563       };
22564     }
22565   }
22566
22567   jresult = (void *)result;
22568
22569   //argout typemap for const std::string&
22570
22571   return jresult;
22572 }
22573
22574
22575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22576   void * jresult ;
22577   Dali::TypeRegistration *arg1 = 0 ;
22578   std::string *arg2 = 0 ;
22579   Dali::Property::Index arg3 ;
22580   Dali::Property::Value *arg4 = 0 ;
22581   Dali::AnimatablePropertyRegistration *result = 0 ;
22582
22583   arg1 = (Dali::TypeRegistration *)jarg1;
22584   if (!arg1) {
22585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22586     return 0;
22587   }
22588   if (!jarg2) {
22589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22590     return 0;
22591   }
22592   std::string arg2_str(jarg2);
22593   arg2 = &arg2_str;
22594   arg3 = (Dali::Property::Index)jarg3;
22595   arg4 = (Dali::Property::Value *)jarg4;
22596   if (!arg4) {
22597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22598     return 0;
22599   }
22600   {
22601     try {
22602       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (Dali::DaliException e) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22614       };
22615     } catch (...) {
22616       {
22617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22618       };
22619     }
22620   }
22621
22622   jresult = (void *)result;
22623
22624   //argout typemap for const std::string&
22625
22626   return jresult;
22627 }
22628
22629
22630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22631   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22632
22633   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22634   {
22635     try {
22636       delete arg1;
22637     } catch (std::out_of_range& e) {
22638       {
22639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (std::exception& e) {
22642       {
22643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22644       };
22645     } catch (Dali::DaliException e) {
22646       {
22647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22648       };
22649     } catch (...) {
22650       {
22651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22652       };
22653     }
22654   }
22655
22656 }
22657
22658
22659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22660   void * jresult ;
22661   Dali::TypeRegistration *arg1 = 0 ;
22662   std::string *arg2 = 0 ;
22663   Dali::Property::Index arg3 ;
22664   Dali::Property::Index arg4 ;
22665   unsigned int arg5 ;
22666   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22667
22668   arg1 = (Dali::TypeRegistration *)jarg1;
22669   if (!arg1) {
22670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22671     return 0;
22672   }
22673   if (!jarg2) {
22674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22675     return 0;
22676   }
22677   std::string arg2_str(jarg2);
22678   arg2 = &arg2_str;
22679   arg3 = (Dali::Property::Index)jarg3;
22680   arg4 = (Dali::Property::Index)jarg4;
22681   arg5 = (unsigned int)jarg5;
22682   {
22683     try {
22684       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (Dali::DaliException e) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22696       };
22697     } catch (...) {
22698       {
22699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22700       };
22701     }
22702   }
22703
22704   jresult = (void *)result;
22705
22706   //argout typemap for const std::string&
22707
22708   return jresult;
22709 }
22710
22711
22712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22713   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22714
22715   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22716   {
22717     try {
22718       delete arg1;
22719     } catch (std::out_of_range& e) {
22720       {
22721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22722       };
22723     } catch (std::exception& e) {
22724       {
22725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22726       };
22727     } catch (Dali::DaliException e) {
22728       {
22729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22730       };
22731     } catch (...) {
22732       {
22733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22734       };
22735     }
22736   }
22737
22738 }
22739
22740
22741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22742   void * jresult ;
22743   Dali::TypeRegistration *arg1 = 0 ;
22744   std::string *arg2 = 0 ;
22745   Dali::Property::Index arg3 ;
22746   Dali::Property::Type arg4 ;
22747   Dali::ChildPropertyRegistration *result = 0 ;
22748
22749   arg1 = (Dali::TypeRegistration *)jarg1;
22750   if (!arg1) {
22751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22752     return 0;
22753   }
22754   if (!jarg2) {
22755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22756     return 0;
22757   }
22758   std::string arg2_str(jarg2);
22759   arg2 = &arg2_str;
22760   arg3 = (Dali::Property::Index)jarg3;
22761   arg4 = (Dali::Property::Type)jarg4;
22762   {
22763     try {
22764       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22765     } catch (std::out_of_range& e) {
22766       {
22767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22768       };
22769     } catch (std::exception& e) {
22770       {
22771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22772       };
22773     } catch (Dali::DaliException e) {
22774       {
22775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22776       };
22777     } catch (...) {
22778       {
22779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22780       };
22781     }
22782   }
22783
22784   jresult = (void *)result;
22785
22786   //argout typemap for const std::string&
22787
22788   return jresult;
22789 }
22790
22791
22792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22793   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22794
22795   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22796   {
22797     try {
22798       delete arg1;
22799     } catch (std::out_of_range& e) {
22800       {
22801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22802       };
22803     } catch (std::exception& e) {
22804       {
22805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22806       };
22807     } catch (Dali::DaliException e) {
22808       {
22809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22810       };
22811     } catch (...) {
22812       {
22813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22814       };
22815     }
22816   }
22817
22818 }
22819
22820
22821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22822   unsigned int jresult ;
22823   std::string *arg1 = 0 ;
22824   std::type_info *arg2 = 0 ;
22825   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22826   bool result;
22827
22828   if (!jarg1) {
22829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22830     return 0;
22831   }
22832   std::string arg1_str(jarg1);
22833   arg1 = &arg1_str;
22834   arg2 = (std::type_info *)jarg2;
22835   if (!arg2) {
22836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22837     return 0;
22838   }
22839   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22840   {
22841     try {
22842       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22843     } catch (std::out_of_range& e) {
22844       {
22845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22846       };
22847     } catch (std::exception& e) {
22848       {
22849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22850       };
22851     } catch (Dali::DaliException e) {
22852       {
22853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22854       };
22855     } catch (...) {
22856       {
22857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22858       };
22859     }
22860   }
22861
22862   jresult = result;
22863
22864   //argout typemap for const std::string&
22865
22866   return jresult;
22867 }
22868
22869
22870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22871   unsigned int jresult ;
22872   std::string *arg1 = 0 ;
22873   std::string *arg2 = 0 ;
22874   Dali::Property::Index arg3 ;
22875   Dali::Property::Type arg4 ;
22876   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22877   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22878   bool result;
22879
22880   if (!jarg1) {
22881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22882     return 0;
22883   }
22884   std::string arg1_str(jarg1);
22885   arg1 = &arg1_str;
22886   if (!jarg2) {
22887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22888     return 0;
22889   }
22890   std::string arg2_str(jarg2);
22891   arg2 = &arg2_str;
22892   arg3 = (Dali::Property::Index)jarg3;
22893   arg4 = (Dali::Property::Type)jarg4;
22894   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22895   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22896   {
22897     try {
22898       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22899     } catch (std::out_of_range& e) {
22900       {
22901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22902       };
22903     } catch (std::exception& e) {
22904       {
22905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22906       };
22907     } catch (Dali::DaliException e) {
22908       {
22909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22910       };
22911     } catch (...) {
22912       {
22913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22914       };
22915     }
22916   }
22917
22918   jresult = result;
22919
22920   //argout typemap for const std::string&
22921
22922
22923   //argout typemap for const std::string&
22924
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::TOP;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::LEFT;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22960   float jresult ;
22961   float result;
22962
22963   result = (float)(float)Dali::ParentOrigin::RIGHT;
22964   jresult = result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22970   float jresult ;
22971   float result;
22972
22973   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22974   jresult = result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23050   void * jresult ;
23051   Dali::Vector3 *result = 0 ;
23052
23053   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23054   jresult = (void *)result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23060   void * jresult ;
23061   Dali::Vector3 *result = 0 ;
23062
23063   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23064   jresult = (void *)result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::TOP;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::LEFT;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23100   float jresult ;
23101   float result;
23102
23103   result = (float)(float)Dali::AnchorPoint::RIGHT;
23104   jresult = result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23110   float jresult ;
23111   float result;
23112
23113   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23114   jresult = result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23190   void * jresult ;
23191   Dali::Vector3 *result = 0 ;
23192
23193   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23200   void * jresult ;
23201   Dali::Vector3 *result = 0 ;
23202
23203   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::RED;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23280   void * jresult ;
23281   Dali::Vector4 *result = 0 ;
23282
23283   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23284   jresult = (void *)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23290   void * jresult ;
23291   Dali::Vector4 *result = 0 ;
23292
23293   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23294   jresult = (void *)result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_2;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::PI_4;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23390   float jresult ;
23391   float result;
23392
23393   result = (float)(float)Dali::Math::PI_OVER_180;
23394   jresult = result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23400   float jresult ;
23401   float result;
23402
23403   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23404   jresult = result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23410   int jresult ;
23411   Dali::ResizePolicy::Type result;
23412
23413   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23420   unsigned long jresult ;
23421   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23422   Dali::VectorBase::SizeType result;
23423
23424   arg1 = (Dali::VectorBase *)jarg1;
23425   {
23426     try {
23427       result = ((Dali::VectorBase const *)arg1)->Count();
23428     } catch (std::out_of_range& e) {
23429       {
23430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23431       };
23432     } catch (std::exception& e) {
23433       {
23434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23435       };
23436     } catch (Dali::DaliException e) {
23437       {
23438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23439       };
23440     } catch (...) {
23441       {
23442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23443       };
23444     }
23445   }
23446
23447   jresult = (unsigned long)result;
23448   return jresult;
23449 }
23450
23451
23452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23453   unsigned long jresult ;
23454   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23455   Dali::VectorBase::SizeType result;
23456
23457   arg1 = (Dali::VectorBase *)jarg1;
23458   {
23459     try {
23460       result = ((Dali::VectorBase const *)arg1)->Size();
23461     } catch (std::out_of_range& e) {
23462       {
23463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23464       };
23465     } catch (std::exception& e) {
23466       {
23467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23468       };
23469     } catch (Dali::DaliException e) {
23470       {
23471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23472       };
23473     } catch (...) {
23474       {
23475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23476       };
23477     }
23478   }
23479
23480   jresult = (unsigned long)result;
23481   return jresult;
23482 }
23483
23484
23485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23486   unsigned int jresult ;
23487   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23488   bool result;
23489
23490   arg1 = (Dali::VectorBase *)jarg1;
23491   {
23492     try {
23493       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23494     } catch (std::out_of_range& e) {
23495       {
23496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23497       };
23498     } catch (std::exception& e) {
23499       {
23500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23501       };
23502     } catch (Dali::DaliException e) {
23503       {
23504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23505       };
23506     } catch (...) {
23507       {
23508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23509       };
23510     }
23511   }
23512
23513   jresult = result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23519   unsigned long jresult ;
23520   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23521   Dali::VectorBase::SizeType result;
23522
23523   arg1 = (Dali::VectorBase *)jarg1;
23524   {
23525     try {
23526       result = ((Dali::VectorBase const *)arg1)->Capacity();
23527     } catch (std::out_of_range& e) {
23528       {
23529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23530       };
23531     } catch (std::exception& e) {
23532       {
23533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23534       };
23535     } catch (Dali::DaliException e) {
23536       {
23537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23538       };
23539     } catch (...) {
23540       {
23541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23542       };
23543     }
23544   }
23545
23546   jresult = (unsigned long)result;
23547   return jresult;
23548 }
23549
23550
23551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23552   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23553
23554   arg1 = (Dali::VectorBase *)jarg1;
23555   {
23556     try {
23557       (arg1)->Release();
23558     } catch (std::out_of_range& e) {
23559       {
23560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23561       };
23562     } catch (std::exception& e) {
23563       {
23564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23565       };
23566     } catch (Dali::DaliException e) {
23567       {
23568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23569       };
23570     } catch (...) {
23571       {
23572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23573       };
23574     }
23575   }
23576
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23581   int jresult ;
23582   Dali::Pixel::Format result;
23583
23584   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23591   int jresult ;
23592   Dali::Pixel::Format result;
23593
23594   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23601   unsigned int jresult ;
23602   Dali::Pixel::Format arg1 ;
23603   bool result;
23604
23605   arg1 = (Dali::Pixel::Format)jarg1;
23606   {
23607     try {
23608       result = (bool)Dali::Pixel::HasAlpha(arg1);
23609     } catch (std::out_of_range& e) {
23610       {
23611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23612       };
23613     } catch (std::exception& e) {
23614       {
23615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23616       };
23617     } catch (Dali::DaliException e) {
23618       {
23619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23620       };
23621     } catch (...) {
23622       {
23623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23624       };
23625     }
23626   }
23627
23628   jresult = result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23634   unsigned int jresult ;
23635   Dali::Pixel::Format arg1 ;
23636   unsigned int result;
23637
23638   arg1 = (Dali::Pixel::Format)jarg1;
23639   {
23640     try {
23641       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23642     } catch (std::out_of_range& e) {
23643       {
23644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23645       };
23646     } catch (std::exception& e) {
23647       {
23648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23649       };
23650     } catch (Dali::DaliException e) {
23651       {
23652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23653       };
23654     } catch (...) {
23655       {
23656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23657       };
23658     }
23659   }
23660
23661   jresult = result;
23662   return jresult;
23663 }
23664
23665
23666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23667   Dali::Pixel::Format arg1 ;
23668   int *arg2 = 0 ;
23669   int *arg3 = 0 ;
23670
23671   arg1 = (Dali::Pixel::Format)jarg1;
23672   arg2 = (int *)jarg2;
23673   if (!arg2) {
23674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23675     return ;
23676   }
23677   arg3 = (int *)jarg3;
23678   if (!arg3) {
23679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23680     return ;
23681   }
23682   {
23683     try {
23684       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23685     } catch (std::out_of_range& e) {
23686       {
23687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23688       };
23689     } catch (std::exception& e) {
23690       {
23691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23692       };
23693     } catch (Dali::DaliException e) {
23694       {
23695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23700       };
23701     }
23702   }
23703
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23708   void * jresult ;
23709   unsigned char *arg1 = (unsigned char *) 0 ;
23710   unsigned int arg2 ;
23711   unsigned int arg3 ;
23712   unsigned int arg4 ;
23713   Dali::Pixel::Format arg5 ;
23714   Dali::PixelData::ReleaseFunction arg6 ;
23715   Dali::PixelData result;
23716
23717   arg1 = jarg1;
23718   arg2 = (unsigned int)jarg2;
23719   arg3 = (unsigned int)jarg3;
23720   arg4 = (unsigned int)jarg4;
23721   arg5 = (Dali::Pixel::Format)jarg5;
23722   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23723   {
23724     try {
23725       auto pixelBuffer = new unsigned char[jarg2];
23726       memcpy( pixelBuffer, arg1, arg2);
23727       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23728     } catch (std::out_of_range& e) {
23729       {
23730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23731       };
23732     } catch (std::exception& e) {
23733       {
23734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23735       };
23736     } catch (Dali::DaliException e) {
23737       {
23738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23739       };
23740     } catch (...) {
23741       {
23742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23743       };
23744     }
23745   }
23746
23747   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23748
23749
23750   return jresult;
23751 }
23752
23753
23754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23755   void * jresult ;
23756   Dali::PixelData *result = 0 ;
23757
23758   {
23759     try {
23760       result = (Dali::PixelData *)new Dali::PixelData();
23761     } catch (std::out_of_range& e) {
23762       {
23763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23764       };
23765     } catch (std::exception& e) {
23766       {
23767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23768       };
23769     } catch (Dali::DaliException e) {
23770       {
23771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23772       };
23773     } catch (...) {
23774       {
23775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23776       };
23777     }
23778   }
23779
23780   jresult = (void *)result;
23781   return jresult;
23782 }
23783
23784
23785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23786   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23787
23788   arg1 = (Dali::PixelData *)jarg1;
23789   {
23790     try {
23791       delete arg1;
23792     } catch (std::out_of_range& e) {
23793       {
23794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23795       };
23796     } catch (std::exception& e) {
23797       {
23798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23799       };
23800     } catch (Dali::DaliException e) {
23801       {
23802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23803       };
23804     } catch (...) {
23805       {
23806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23807       };
23808     }
23809   }
23810
23811 }
23812
23813
23814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23815   void * jresult ;
23816   Dali::PixelData *arg1 = 0 ;
23817   Dali::PixelData *result = 0 ;
23818
23819   arg1 = (Dali::PixelData *)jarg1;
23820   if (!arg1) {
23821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23822     return 0;
23823   }
23824   {
23825     try {
23826       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23827     } catch (std::out_of_range& e) {
23828       {
23829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23830       };
23831     } catch (std::exception& e) {
23832       {
23833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23834       };
23835     } catch (Dali::DaliException e) {
23836       {
23837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23838       };
23839     } catch (...) {
23840       {
23841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23842       };
23843     }
23844   }
23845
23846   jresult = (void *)result;
23847   return jresult;
23848 }
23849
23850
23851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23852   void * jresult ;
23853   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23854   Dali::PixelData *arg2 = 0 ;
23855   Dali::PixelData *result = 0 ;
23856
23857   arg1 = (Dali::PixelData *)jarg1;
23858   arg2 = (Dali::PixelData *)jarg2;
23859   if (!arg2) {
23860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23861     return 0;
23862   }
23863   {
23864     try {
23865       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23866     } catch (std::out_of_range& e) {
23867       {
23868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (std::exception& e) {
23871       {
23872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23873       };
23874     } catch (Dali::DaliException e) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23877       };
23878     } catch (...) {
23879       {
23880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23881       };
23882     }
23883   }
23884
23885   jresult = (void *)result;
23886   return jresult;
23887 }
23888
23889
23890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23891   unsigned int jresult ;
23892   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23893   unsigned int result;
23894
23895   arg1 = (Dali::PixelData *)jarg1;
23896   {
23897     try {
23898       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23899     } catch (std::out_of_range& e) {
23900       {
23901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (std::exception& e) {
23904       {
23905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23906       };
23907     } catch (Dali::DaliException e) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23910       };
23911     } catch (...) {
23912       {
23913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23914       };
23915     }
23916   }
23917
23918   jresult = result;
23919   return jresult;
23920 }
23921
23922
23923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23924   unsigned int jresult ;
23925   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23926   unsigned int result;
23927
23928   arg1 = (Dali::PixelData *)jarg1;
23929   {
23930     try {
23931       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23939       };
23940     } catch (Dali::DaliException e) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23943       };
23944     } catch (...) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23947       };
23948     }
23949   }
23950
23951   jresult = result;
23952   return jresult;
23953 }
23954
23955
23956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23957   int jresult ;
23958   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23959   Dali::Pixel::Format result;
23960
23961   arg1 = (Dali::PixelData *)jarg1;
23962   {
23963     try {
23964       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23965     } catch (std::out_of_range& e) {
23966       {
23967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23968       };
23969     } catch (std::exception& e) {
23970       {
23971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23972       };
23973     } catch (Dali::DaliException e) {
23974       {
23975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23976       };
23977     } catch (...) {
23978       {
23979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23980       };
23981     }
23982   }
23983
23984   jresult = (int)result;
23985   return jresult;
23986 }
23987
23988
23989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23990   unsigned int jresult ;
23991   unsigned int result;
23992
23993   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23994   jresult = result;
23995   return jresult;
23996 }
23997
23998
23999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24000   unsigned int jresult ;
24001   unsigned int result;
24002
24003   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24004   jresult = result;
24005   return jresult;
24006 }
24007
24008
24009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24010   unsigned int jresult ;
24011   unsigned int result;
24012
24013   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24014   jresult = result;
24015   return jresult;
24016 }
24017
24018
24019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24020   unsigned int jresult ;
24021   unsigned int result;
24022
24023   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24024   jresult = result;
24025   return jresult;
24026 }
24027
24028
24029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24030   unsigned int jresult ;
24031   unsigned int result;
24032
24033   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24034   jresult = result;
24035   return jresult;
24036 }
24037
24038
24039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24040   unsigned int jresult ;
24041   unsigned int result;
24042
24043   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24044   jresult = result;
24045   return jresult;
24046 }
24047
24048
24049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24050   void * jresult ;
24051   Dali::TextureType::Type arg1 ;
24052   Dali::Pixel::Format arg2 ;
24053   unsigned int arg3 ;
24054   unsigned int arg4 ;
24055   Dali::Texture result;
24056
24057   arg1 = (Dali::TextureType::Type)jarg1;
24058   arg2 = (Dali::Pixel::Format)jarg2;
24059   arg3 = (unsigned int)jarg3;
24060   arg4 = (unsigned int)jarg4;
24061   {
24062     try {
24063       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24064     } catch (std::out_of_range& e) {
24065       {
24066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24067       };
24068     } catch (std::exception& e) {
24069       {
24070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24071       };
24072     } catch (Dali::DaliException e) {
24073       {
24074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24075       };
24076     } catch (...) {
24077       {
24078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24079       };
24080     }
24081   }
24082
24083   jresult = new Dali::Texture((const Dali::Texture &)result);
24084   return jresult;
24085 }
24086
24087
24088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24089   void * jresult ;
24090   NativeImageInterface *arg1 = 0 ;
24091   Dali::Texture result;
24092
24093   arg1 = (NativeImageInterface *)jarg1;
24094   if (!arg1) {
24095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24096     return 0;
24097   }
24098   {
24099     try {
24100       result = Dali::Texture::New(*arg1);
24101     } catch (std::out_of_range& e) {
24102       {
24103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24104       };
24105     } catch (std::exception& e) {
24106       {
24107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24108       };
24109     } catch (Dali::DaliException e) {
24110       {
24111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24112       };
24113     } catch (...) {
24114       {
24115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24116       };
24117     }
24118   }
24119
24120   jresult = new Dali::Texture((const Dali::Texture &)result);
24121   return jresult;
24122 }
24123
24124
24125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24126   void * jresult ;
24127   Dali::Texture *result = 0 ;
24128
24129   {
24130     try {
24131       result = (Dali::Texture *)new Dali::Texture();
24132     } catch (std::out_of_range& e) {
24133       {
24134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24135       };
24136     } catch (std::exception& e) {
24137       {
24138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24139       };
24140     } catch (Dali::DaliException e) {
24141       {
24142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24143       };
24144     } catch (...) {
24145       {
24146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24147       };
24148     }
24149   }
24150
24151   jresult = (void *)result;
24152   return jresult;
24153 }
24154
24155
24156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24157   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24158
24159   arg1 = (Dali::Texture *)jarg1;
24160   {
24161     try {
24162       delete arg1;
24163     } catch (std::out_of_range& e) {
24164       {
24165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24166       };
24167     } catch (std::exception& e) {
24168       {
24169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24170       };
24171     } catch (Dali::DaliException e) {
24172       {
24173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24174       };
24175     } catch (...) {
24176       {
24177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24178       };
24179     }
24180   }
24181
24182 }
24183
24184
24185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24186   void * jresult ;
24187   Dali::Texture *arg1 = 0 ;
24188   Dali::Texture *result = 0 ;
24189
24190   arg1 = (Dali::Texture *)jarg1;
24191   if (!arg1) {
24192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24193     return 0;
24194   }
24195   {
24196     try {
24197       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24198     } catch (std::out_of_range& e) {
24199       {
24200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24201       };
24202     } catch (std::exception& e) {
24203       {
24204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24205       };
24206     } catch (Dali::DaliException e) {
24207       {
24208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24209       };
24210     } catch (...) {
24211       {
24212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24213       };
24214     }
24215   }
24216
24217   jresult = (void *)result;
24218   return jresult;
24219 }
24220
24221
24222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24223   void * jresult ;
24224   Dali::BaseHandle arg1 ;
24225   Dali::BaseHandle *argp1 ;
24226   Dali::Texture result;
24227
24228   argp1 = (Dali::BaseHandle *)jarg1;
24229   if (!argp1) {
24230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24231     return 0;
24232   }
24233   arg1 = *argp1;
24234   {
24235     try {
24236       result = Dali::Texture::DownCast(arg1);
24237     } catch (std::out_of_range& e) {
24238       {
24239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24240       };
24241     } catch (std::exception& e) {
24242       {
24243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24244       };
24245     } catch (Dali::DaliException e) {
24246       {
24247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24248       };
24249     } catch (...) {
24250       {
24251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24252       };
24253     }
24254   }
24255
24256   jresult = new Dali::Texture((const Dali::Texture &)result);
24257   return jresult;
24258 }
24259
24260
24261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24262   void * jresult ;
24263   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24264   Dali::Texture *arg2 = 0 ;
24265   Dali::Texture *result = 0 ;
24266
24267   arg1 = (Dali::Texture *)jarg1;
24268   arg2 = (Dali::Texture *)jarg2;
24269   if (!arg2) {
24270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24271     return 0;
24272   }
24273   {
24274     try {
24275       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24276     } catch (std::out_of_range& e) {
24277       {
24278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24279       };
24280     } catch (std::exception& e) {
24281       {
24282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24283       };
24284     } catch (Dali::DaliException e) {
24285       {
24286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24287       };
24288     } catch (...) {
24289       {
24290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24291       };
24292     }
24293   }
24294
24295   jresult = (void *)result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24301   unsigned int jresult ;
24302   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24303   Dali::PixelData arg2 ;
24304   Dali::PixelData *argp2 ;
24305   bool result;
24306
24307   arg1 = (Dali::Texture *)jarg1;
24308   argp2 = (Dali::PixelData *)jarg2;
24309   if (!argp2) {
24310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24311     return 0;
24312   }
24313   arg2 = *argp2;
24314   {
24315     try {
24316       result = (bool)(arg1)->Upload(arg2);
24317     } catch (std::out_of_range& e) {
24318       {
24319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (std::exception& e) {
24322       {
24323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24324       };
24325     } catch (Dali::DaliException e) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24328       };
24329     } catch (...) {
24330       {
24331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24332       };
24333     }
24334   }
24335
24336   jresult = result;
24337   return jresult;
24338 }
24339
24340
24341 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) {
24342   unsigned int jresult ;
24343   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24344   Dali::PixelData arg2 ;
24345   unsigned int arg3 ;
24346   unsigned int arg4 ;
24347   unsigned int arg5 ;
24348   unsigned int arg6 ;
24349   unsigned int arg7 ;
24350   unsigned int arg8 ;
24351   Dali::PixelData *argp2 ;
24352   bool result;
24353
24354   arg1 = (Dali::Texture *)jarg1;
24355   argp2 = (Dali::PixelData *)jarg2;
24356   if (!argp2) {
24357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24358     return 0;
24359   }
24360   arg2 = *argp2;
24361   arg3 = (unsigned int)jarg3;
24362   arg4 = (unsigned int)jarg4;
24363   arg5 = (unsigned int)jarg5;
24364   arg6 = (unsigned int)jarg6;
24365   arg7 = (unsigned int)jarg7;
24366   arg8 = (unsigned int)jarg8;
24367   {
24368     try {
24369       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24370     } catch (std::out_of_range& e) {
24371       {
24372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24373       };
24374     } catch (std::exception& e) {
24375       {
24376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24377       };
24378     } catch (Dali::DaliException e) {
24379       {
24380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24381       };
24382     } catch (...) {
24383       {
24384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24385       };
24386     }
24387   }
24388
24389   jresult = result;
24390   return jresult;
24391 }
24392
24393
24394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24395   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24396
24397   arg1 = (Dali::Texture *)jarg1;
24398   {
24399     try {
24400       (arg1)->GenerateMipmaps();
24401     } catch (std::out_of_range& e) {
24402       {
24403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24404       };
24405     } catch (std::exception& e) {
24406       {
24407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24408       };
24409     } catch (Dali::DaliException e) {
24410       {
24411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24412       };
24413     } catch (...) {
24414       {
24415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24416       };
24417     }
24418   }
24419
24420 }
24421
24422
24423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24424   unsigned int jresult ;
24425   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24426   unsigned int result;
24427
24428   arg1 = (Dali::Texture *)jarg1;
24429   {
24430     try {
24431       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24432     } catch (std::out_of_range& e) {
24433       {
24434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24435       };
24436     } catch (std::exception& e) {
24437       {
24438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24439       };
24440     } catch (Dali::DaliException e) {
24441       {
24442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24443       };
24444     } catch (...) {
24445       {
24446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24447       };
24448     }
24449   }
24450
24451   jresult = result;
24452   return jresult;
24453 }
24454
24455
24456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24457   unsigned int jresult ;
24458   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24459   unsigned int result;
24460
24461   arg1 = (Dali::Texture *)jarg1;
24462   {
24463     try {
24464       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24465     } catch (std::out_of_range& e) {
24466       {
24467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (std::exception& e) {
24470       {
24471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24472       };
24473     } catch (Dali::DaliException e) {
24474       {
24475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24476       };
24477     } catch (...) {
24478       {
24479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24480       };
24481     }
24482   }
24483
24484   jresult = result;
24485   return jresult;
24486 }
24487
24488
24489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24490   void * jresult ;
24491   Dali::Sampler result;
24492
24493   {
24494     try {
24495       result = Dali::Sampler::New();
24496     } catch (std::out_of_range& e) {
24497       {
24498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24499       };
24500     } catch (std::exception& e) {
24501       {
24502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24503       };
24504     } catch (Dali::DaliException e) {
24505       {
24506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24507       };
24508     } catch (...) {
24509       {
24510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24511       };
24512     }
24513   }
24514
24515   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24516   return jresult;
24517 }
24518
24519
24520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24521   void * jresult ;
24522   Dali::Sampler *result = 0 ;
24523
24524   {
24525     try {
24526       result = (Dali::Sampler *)new Dali::Sampler();
24527     } catch (std::out_of_range& e) {
24528       {
24529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (std::exception& e) {
24532       {
24533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (Dali::DaliException e) {
24536       {
24537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24538       };
24539     } catch (...) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24542       };
24543     }
24544   }
24545
24546   jresult = (void *)result;
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24552   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24553
24554   arg1 = (Dali::Sampler *)jarg1;
24555   {
24556     try {
24557       delete arg1;
24558     } catch (std::out_of_range& e) {
24559       {
24560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24561       };
24562     } catch (std::exception& e) {
24563       {
24564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24565       };
24566     } catch (Dali::DaliException e) {
24567       {
24568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24569       };
24570     } catch (...) {
24571       {
24572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24573       };
24574     }
24575   }
24576
24577 }
24578
24579
24580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24581   void * jresult ;
24582   Dali::Sampler *arg1 = 0 ;
24583   Dali::Sampler *result = 0 ;
24584
24585   arg1 = (Dali::Sampler *)jarg1;
24586   if (!arg1) {
24587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24588     return 0;
24589   }
24590   {
24591     try {
24592       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24593     } catch (std::out_of_range& e) {
24594       {
24595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24596       };
24597     } catch (std::exception& e) {
24598       {
24599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24600       };
24601     } catch (Dali::DaliException e) {
24602       {
24603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24604       };
24605     } catch (...) {
24606       {
24607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24608       };
24609     }
24610   }
24611
24612   jresult = (void *)result;
24613   return jresult;
24614 }
24615
24616
24617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24618   void * jresult ;
24619   Dali::BaseHandle arg1 ;
24620   Dali::BaseHandle *argp1 ;
24621   Dali::Sampler result;
24622
24623   argp1 = (Dali::BaseHandle *)jarg1;
24624   if (!argp1) {
24625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24626     return 0;
24627   }
24628   arg1 = *argp1;
24629   {
24630     try {
24631       result = Dali::Sampler::DownCast(arg1);
24632     } catch (std::out_of_range& e) {
24633       {
24634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24635       };
24636     } catch (std::exception& e) {
24637       {
24638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24639       };
24640     } catch (Dali::DaliException e) {
24641       {
24642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24643       };
24644     } catch (...) {
24645       {
24646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24647       };
24648     }
24649   }
24650
24651   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24652   return jresult;
24653 }
24654
24655
24656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24657   void * jresult ;
24658   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24659   Dali::Sampler *arg2 = 0 ;
24660   Dali::Sampler *result = 0 ;
24661
24662   arg1 = (Dali::Sampler *)jarg1;
24663   arg2 = (Dali::Sampler *)jarg2;
24664   if (!arg2) {
24665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24666     return 0;
24667   }
24668   {
24669     try {
24670       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24671     } catch (std::out_of_range& e) {
24672       {
24673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24674       };
24675     } catch (std::exception& e) {
24676       {
24677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24678       };
24679     } catch (Dali::DaliException e) {
24680       {
24681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24682       };
24683     } catch (...) {
24684       {
24685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24686       };
24687     }
24688   }
24689
24690   jresult = (void *)result;
24691   return jresult;
24692 }
24693
24694
24695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24696   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24697   Dali::FilterMode::Type arg2 ;
24698   Dali::FilterMode::Type arg3 ;
24699
24700   arg1 = (Dali::Sampler *)jarg1;
24701   arg2 = (Dali::FilterMode::Type)jarg2;
24702   arg3 = (Dali::FilterMode::Type)jarg3;
24703   {
24704     try {
24705       (arg1)->SetFilterMode(arg2,arg3);
24706     } catch (std::out_of_range& e) {
24707       {
24708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24709       };
24710     } catch (std::exception& e) {
24711       {
24712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24713       };
24714     } catch (Dali::DaliException e) {
24715       {
24716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24717       };
24718     } catch (...) {
24719       {
24720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24721       };
24722     }
24723   }
24724
24725 }
24726
24727
24728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24729   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24730   Dali::WrapMode::Type arg2 ;
24731   Dali::WrapMode::Type arg3 ;
24732
24733   arg1 = (Dali::Sampler *)jarg1;
24734   arg2 = (Dali::WrapMode::Type)jarg2;
24735   arg3 = (Dali::WrapMode::Type)jarg3;
24736   {
24737     try {
24738       (arg1)->SetWrapMode(arg2,arg3);
24739     } catch (std::out_of_range& e) {
24740       {
24741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24742       };
24743     } catch (std::exception& e) {
24744       {
24745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24746       };
24747     } catch (Dali::DaliException e) {
24748       {
24749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24750       };
24751     } catch (...) {
24752       {
24753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24754       };
24755     }
24756   }
24757
24758 }
24759
24760
24761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24762   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24763   Dali::WrapMode::Type arg2 ;
24764   Dali::WrapMode::Type arg3 ;
24765   Dali::WrapMode::Type arg4 ;
24766
24767   arg1 = (Dali::Sampler *)jarg1;
24768   arg2 = (Dali::WrapMode::Type)jarg2;
24769   arg3 = (Dali::WrapMode::Type)jarg3;
24770   arg4 = (Dali::WrapMode::Type)jarg4;
24771   {
24772     try {
24773       (arg1)->SetWrapMode(arg2,arg3,arg4);
24774     } catch (std::out_of_range& e) {
24775       {
24776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24777       };
24778     } catch (std::exception& e) {
24779       {
24780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24781       };
24782     } catch (Dali::DaliException e) {
24783       {
24784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24785       };
24786     } catch (...) {
24787       {
24788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24789       };
24790     }
24791   }
24792
24793 }
24794
24795
24796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24797   void * jresult ;
24798   Dali::TextureSet result;
24799
24800   {
24801     try {
24802       result = Dali::TextureSet::New();
24803     } catch (std::out_of_range& e) {
24804       {
24805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24806       };
24807     } catch (std::exception& e) {
24808       {
24809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24810       };
24811     } catch (Dali::DaliException e) {
24812       {
24813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24814       };
24815     } catch (...) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24818       };
24819     }
24820   }
24821
24822   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24823   return jresult;
24824 }
24825
24826
24827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24828   void * jresult ;
24829   Dali::TextureSet *result = 0 ;
24830
24831   {
24832     try {
24833       result = (Dali::TextureSet *)new Dali::TextureSet();
24834     } catch (std::out_of_range& e) {
24835       {
24836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24837       };
24838     } catch (std::exception& e) {
24839       {
24840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24841       };
24842     } catch (Dali::DaliException e) {
24843       {
24844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24845       };
24846     } catch (...) {
24847       {
24848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24849       };
24850     }
24851   }
24852
24853   jresult = (void *)result;
24854   return jresult;
24855 }
24856
24857
24858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24859   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24860
24861   arg1 = (Dali::TextureSet *)jarg1;
24862   {
24863     try {
24864       delete arg1;
24865     } catch (std::out_of_range& e) {
24866       {
24867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24868       };
24869     } catch (std::exception& e) {
24870       {
24871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24872       };
24873     } catch (Dali::DaliException e) {
24874       {
24875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24876       };
24877     } catch (...) {
24878       {
24879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24880       };
24881     }
24882   }
24883
24884 }
24885
24886
24887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24888   void * jresult ;
24889   Dali::TextureSet *arg1 = 0 ;
24890   Dali::TextureSet *result = 0 ;
24891
24892   arg1 = (Dali::TextureSet *)jarg1;
24893   if (!arg1) {
24894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24895     return 0;
24896   }
24897   {
24898     try {
24899       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24900     } catch (std::out_of_range& e) {
24901       {
24902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24903       };
24904     } catch (std::exception& e) {
24905       {
24906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24907       };
24908     } catch (Dali::DaliException e) {
24909       {
24910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24911       };
24912     } catch (...) {
24913       {
24914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24915       };
24916     }
24917   }
24918
24919   jresult = (void *)result;
24920   return jresult;
24921 }
24922
24923
24924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24925   void * jresult ;
24926   Dali::BaseHandle arg1 ;
24927   Dali::BaseHandle *argp1 ;
24928   Dali::TextureSet result;
24929
24930   argp1 = (Dali::BaseHandle *)jarg1;
24931   if (!argp1) {
24932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24933     return 0;
24934   }
24935   arg1 = *argp1;
24936   {
24937     try {
24938       result = Dali::TextureSet::DownCast(arg1);
24939     } catch (std::out_of_range& e) {
24940       {
24941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24942       };
24943     } catch (std::exception& e) {
24944       {
24945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24946       };
24947     } catch (Dali::DaliException e) {
24948       {
24949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24950       };
24951     } catch (...) {
24952       {
24953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24954       };
24955     }
24956   }
24957
24958   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24959   return jresult;
24960 }
24961
24962
24963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24964   void * jresult ;
24965   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24966   Dali::TextureSet *arg2 = 0 ;
24967   Dali::TextureSet *result = 0 ;
24968
24969   arg1 = (Dali::TextureSet *)jarg1;
24970   arg2 = (Dali::TextureSet *)jarg2;
24971   if (!arg2) {
24972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24973     return 0;
24974   }
24975   {
24976     try {
24977       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24978     } catch (std::out_of_range& e) {
24979       {
24980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24981       };
24982     } catch (std::exception& e) {
24983       {
24984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24985       };
24986     } catch (Dali::DaliException e) {
24987       {
24988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24989       };
24990     } catch (...) {
24991       {
24992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24993       };
24994     }
24995   }
24996
24997   jresult = (void *)result;
24998   return jresult;
24999 }
25000
25001
25002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25003   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25004   size_t arg2 ;
25005   Dali::Texture arg3 ;
25006   Dali::Texture *argp3 ;
25007
25008   arg1 = (Dali::TextureSet *)jarg1;
25009   arg2 = (size_t)jarg2;
25010   argp3 = (Dali::Texture *)jarg3;
25011   if (!argp3) {
25012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25013     return ;
25014   }
25015   arg3 = *argp3;
25016   {
25017     try {
25018       (arg1)->SetTexture(arg2,arg3);
25019     } catch (std::out_of_range& e) {
25020       {
25021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25022       };
25023     } catch (std::exception& e) {
25024       {
25025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25026       };
25027     } catch (Dali::DaliException e) {
25028       {
25029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25030       };
25031     } catch (...) {
25032       {
25033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25034       };
25035     }
25036   }
25037
25038 }
25039
25040
25041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25042   void * jresult ;
25043   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25044   size_t arg2 ;
25045   Dali::Texture result;
25046
25047   arg1 = (Dali::TextureSet *)jarg1;
25048   arg2 = (size_t)jarg2;
25049   {
25050     try {
25051       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25067       };
25068     }
25069   }
25070
25071   jresult = new Dali::Texture((const Dali::Texture &)result);
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25077   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25078   size_t arg2 ;
25079   Dali::Sampler arg3 ;
25080   Dali::Sampler *argp3 ;
25081
25082   arg1 = (Dali::TextureSet *)jarg1;
25083   arg2 = (size_t)jarg2;
25084   argp3 = (Dali::Sampler *)jarg3;
25085   if (!argp3) {
25086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25087     return ;
25088   }
25089   arg3 = *argp3;
25090   {
25091     try {
25092       (arg1)->SetSampler(arg2,arg3);
25093     } catch (std::out_of_range& e) {
25094       {
25095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25096       };
25097     } catch (std::exception& e) {
25098       {
25099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25100       };
25101     } catch (Dali::DaliException e) {
25102       {
25103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25104       };
25105     } catch (...) {
25106       {
25107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25108       };
25109     }
25110   }
25111
25112 }
25113
25114
25115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25116   void * jresult ;
25117   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25118   size_t arg2 ;
25119   Dali::Sampler result;
25120
25121   arg1 = (Dali::TextureSet *)jarg1;
25122   arg2 = (size_t)jarg2;
25123   {
25124     try {
25125       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25126     } catch (std::out_of_range& e) {
25127       {
25128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25129       };
25130     } catch (std::exception& e) {
25131       {
25132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25133       };
25134     } catch (Dali::DaliException e) {
25135       {
25136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25141       };
25142     }
25143   }
25144
25145   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25146   return jresult;
25147 }
25148
25149
25150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25151   unsigned long jresult ;
25152   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25153   size_t result;
25154
25155   arg1 = (Dali::TextureSet *)jarg1;
25156   {
25157     try {
25158       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25159     } catch (std::out_of_range& e) {
25160       {
25161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (std::exception& e) {
25164       {
25165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25166       };
25167     } catch (Dali::DaliException e) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25170       };
25171     } catch (...) {
25172       {
25173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25174       };
25175     }
25176   }
25177
25178   jresult = (unsigned long)result;
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25184   void * jresult ;
25185   Dali::Property::Map *arg1 = 0 ;
25186   Dali::PropertyBuffer result;
25187
25188   arg1 = (Dali::Property::Map *)jarg1;
25189   if (!arg1) {
25190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25191     return 0;
25192   }
25193   {
25194     try {
25195       result = Dali::PropertyBuffer::New(*arg1);
25196     } catch (std::out_of_range& e) {
25197       {
25198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (std::exception& e) {
25201       {
25202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25203       };
25204     } catch (Dali::DaliException e) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25207       };
25208     } catch (...) {
25209       {
25210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25211       };
25212     }
25213   }
25214
25215   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25216   return jresult;
25217 }
25218
25219
25220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25221   void * jresult ;
25222   Dali::PropertyBuffer *result = 0 ;
25223
25224   {
25225     try {
25226       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25227     } catch (std::out_of_range& e) {
25228       {
25229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25230       };
25231     } catch (std::exception& e) {
25232       {
25233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (Dali::DaliException e) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25238       };
25239     } catch (...) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25242       };
25243     }
25244   }
25245
25246   jresult = (void *)result;
25247   return jresult;
25248 }
25249
25250
25251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25252   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25253
25254   arg1 = (Dali::PropertyBuffer *)jarg1;
25255   {
25256     try {
25257       delete arg1;
25258     } catch (std::out_of_range& e) {
25259       {
25260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25261       };
25262     } catch (std::exception& e) {
25263       {
25264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25265       };
25266     } catch (Dali::DaliException e) {
25267       {
25268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25269       };
25270     } catch (...) {
25271       {
25272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25273       };
25274     }
25275   }
25276
25277 }
25278
25279
25280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25281   void * jresult ;
25282   Dali::PropertyBuffer *arg1 = 0 ;
25283   Dali::PropertyBuffer *result = 0 ;
25284
25285   arg1 = (Dali::PropertyBuffer *)jarg1;
25286   if (!arg1) {
25287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25288     return 0;
25289   }
25290   {
25291     try {
25292       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25293     } catch (std::out_of_range& e) {
25294       {
25295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25296       };
25297     } catch (std::exception& e) {
25298       {
25299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25300       };
25301     } catch (Dali::DaliException e) {
25302       {
25303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25304       };
25305     } catch (...) {
25306       {
25307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25308       };
25309     }
25310   }
25311
25312   jresult = (void *)result;
25313   return jresult;
25314 }
25315
25316
25317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25318   void * jresult ;
25319   Dali::BaseHandle arg1 ;
25320   Dali::BaseHandle *argp1 ;
25321   Dali::PropertyBuffer result;
25322
25323   argp1 = (Dali::BaseHandle *)jarg1;
25324   if (!argp1) {
25325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25326     return 0;
25327   }
25328   arg1 = *argp1;
25329   {
25330     try {
25331       result = Dali::PropertyBuffer::DownCast(arg1);
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (Dali::DaliException e) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25343       };
25344     } catch (...) {
25345       {
25346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25347       };
25348     }
25349   }
25350
25351   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25352   return jresult;
25353 }
25354
25355
25356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25357   void * jresult ;
25358   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25359   Dali::PropertyBuffer *arg2 = 0 ;
25360   Dali::PropertyBuffer *result = 0 ;
25361
25362   arg1 = (Dali::PropertyBuffer *)jarg1;
25363   arg2 = (Dali::PropertyBuffer *)jarg2;
25364   if (!arg2) {
25365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25366     return 0;
25367   }
25368   {
25369     try {
25370       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25371     } catch (std::out_of_range& e) {
25372       {
25373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25374       };
25375     } catch (std::exception& e) {
25376       {
25377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (Dali::DaliException e) {
25380       {
25381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25382       };
25383     } catch (...) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25386       };
25387     }
25388   }
25389
25390   jresult = (void *)result;
25391   return jresult;
25392 }
25393
25394
25395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25396   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25397   void *arg2 = (void *) 0 ;
25398   std::size_t arg3 ;
25399
25400   arg1 = (Dali::PropertyBuffer *)jarg1;
25401   arg2 = jarg2;
25402   arg3 = (std::size_t)jarg3;
25403   {
25404     try {
25405       (arg1)->SetData((void const *)arg2,arg3);
25406     } catch (std::out_of_range& e) {
25407       {
25408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25409       };
25410     } catch (std::exception& e) {
25411       {
25412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25413       };
25414     } catch (Dali::DaliException e) {
25415       {
25416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25417       };
25418     } catch (...) {
25419       {
25420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25421       };
25422     }
25423   }
25424
25425 }
25426
25427
25428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25429   unsigned long jresult ;
25430   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25431   std::size_t result;
25432
25433   arg1 = (Dali::PropertyBuffer *)jarg1;
25434   {
25435     try {
25436       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25437     } catch (std::out_of_range& e) {
25438       {
25439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25440       };
25441     } catch (std::exception& e) {
25442       {
25443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25444       };
25445     } catch (Dali::DaliException e) {
25446       {
25447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25448       };
25449     } catch (...) {
25450       {
25451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25452       };
25453     }
25454   }
25455
25456   jresult = (unsigned long)result;
25457   return jresult;
25458 }
25459
25460
25461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25462   void * jresult ;
25463   Dali::Geometry result;
25464
25465   {
25466     try {
25467       result = Dali::Geometry::New();
25468     } catch (std::out_of_range& e) {
25469       {
25470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25471       };
25472     } catch (std::exception& e) {
25473       {
25474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25475       };
25476     } catch (Dali::DaliException e) {
25477       {
25478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25479       };
25480     } catch (...) {
25481       {
25482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25483       };
25484     }
25485   }
25486
25487   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25488   return jresult;
25489 }
25490
25491
25492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25493   void * jresult ;
25494   Dali::Geometry *result = 0 ;
25495
25496   {
25497     try {
25498       result = (Dali::Geometry *)new Dali::Geometry();
25499     } catch (std::out_of_range& e) {
25500       {
25501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (std::exception& e) {
25504       {
25505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25506       };
25507     } catch (Dali::DaliException e) {
25508       {
25509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25510       };
25511     } catch (...) {
25512       {
25513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25514       };
25515     }
25516   }
25517
25518   jresult = (void *)result;
25519   return jresult;
25520 }
25521
25522
25523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25524   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25525
25526   arg1 = (Dali::Geometry *)jarg1;
25527   {
25528     try {
25529       delete arg1;
25530     } catch (std::out_of_range& e) {
25531       {
25532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25533       };
25534     } catch (std::exception& e) {
25535       {
25536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25537       };
25538     } catch (Dali::DaliException e) {
25539       {
25540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25541       };
25542     } catch (...) {
25543       {
25544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25545       };
25546     }
25547   }
25548
25549 }
25550
25551
25552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25553   void * jresult ;
25554   Dali::Geometry *arg1 = 0 ;
25555   Dali::Geometry *result = 0 ;
25556
25557   arg1 = (Dali::Geometry *)jarg1;
25558   if (!arg1) {
25559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25560     return 0;
25561   }
25562   {
25563     try {
25564       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25565     } catch (std::out_of_range& e) {
25566       {
25567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25568       };
25569     } catch (std::exception& e) {
25570       {
25571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25572       };
25573     } catch (Dali::DaliException e) {
25574       {
25575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25580       };
25581     }
25582   }
25583
25584   jresult = (void *)result;
25585   return jresult;
25586 }
25587
25588
25589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25590   void * jresult ;
25591   Dali::BaseHandle arg1 ;
25592   Dali::BaseHandle *argp1 ;
25593   Dali::Geometry result;
25594
25595   argp1 = (Dali::BaseHandle *)jarg1;
25596   if (!argp1) {
25597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25598     return 0;
25599   }
25600   arg1 = *argp1;
25601   {
25602     try {
25603       result = Dali::Geometry::DownCast(arg1);
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25611       };
25612     } catch (Dali::DaliException e) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25615       };
25616     } catch (...) {
25617       {
25618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25619       };
25620     }
25621   }
25622
25623   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25624   return jresult;
25625 }
25626
25627
25628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25629   void * jresult ;
25630   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25631   Dali::Geometry *arg2 = 0 ;
25632   Dali::Geometry *result = 0 ;
25633
25634   arg1 = (Dali::Geometry *)jarg1;
25635   arg2 = (Dali::Geometry *)jarg2;
25636   if (!arg2) {
25637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25638     return 0;
25639   }
25640   {
25641     try {
25642       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25643     } catch (std::out_of_range& e) {
25644       {
25645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25646       };
25647     } catch (std::exception& e) {
25648       {
25649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25650       };
25651     } catch (Dali::DaliException e) {
25652       {
25653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25654       };
25655     } catch (...) {
25656       {
25657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25658       };
25659     }
25660   }
25661
25662   jresult = (void *)result;
25663   return jresult;
25664 }
25665
25666
25667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25668   unsigned long jresult ;
25669   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25670   Dali::PropertyBuffer *arg2 = 0 ;
25671   std::size_t result;
25672
25673   arg1 = (Dali::Geometry *)jarg1;
25674   arg2 = (Dali::PropertyBuffer *)jarg2;
25675   if (!arg2) {
25676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25677     return 0;
25678   }
25679   {
25680     try {
25681       result = (arg1)->AddVertexBuffer(*arg2);
25682     } catch (std::out_of_range& e) {
25683       {
25684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25685       };
25686     } catch (std::exception& e) {
25687       {
25688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (Dali::DaliException e) {
25691       {
25692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25693       };
25694     } catch (...) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25697       };
25698     }
25699   }
25700
25701   jresult = (unsigned long)result;
25702   return jresult;
25703 }
25704
25705
25706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25707   unsigned long jresult ;
25708   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25709   std::size_t result;
25710
25711   arg1 = (Dali::Geometry *)jarg1;
25712   {
25713     try {
25714       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (Dali::DaliException e) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25726       };
25727     } catch (...) {
25728       {
25729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25730       };
25731     }
25732   }
25733
25734   jresult = (unsigned long)result;
25735   return jresult;
25736 }
25737
25738
25739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25740   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25741   std::size_t arg2 ;
25742
25743   arg1 = (Dali::Geometry *)jarg1;
25744   arg2 = (std::size_t)jarg2;
25745   {
25746     try {
25747       (arg1)->RemoveVertexBuffer(arg2);
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25763       };
25764     }
25765   }
25766
25767 }
25768
25769
25770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25771   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25772   unsigned short *arg2 = (unsigned short *) 0 ;
25773   size_t arg3 ;
25774
25775   arg1 = (Dali::Geometry *)jarg1;
25776   arg2 = jarg2;
25777   arg3 = (size_t)jarg3;
25778   {
25779     try {
25780       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25796       };
25797     }
25798   }
25799
25800
25801
25802 }
25803
25804
25805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25806   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25807   Dali::Geometry::Type arg2 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   arg2 = (Dali::Geometry::Type)jarg2;
25811   {
25812     try {
25813       (arg1)->SetType(arg2);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25821       };
25822     } catch (Dali::DaliException e) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25825       };
25826     } catch (...) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25829       };
25830     }
25831   }
25832
25833 }
25834
25835
25836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25837   int jresult ;
25838   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25839   Dali::Geometry::Type result;
25840
25841   arg1 = (Dali::Geometry *)jarg1;
25842   {
25843     try {
25844       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25845     } catch (std::out_of_range& e) {
25846       {
25847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25848       };
25849     } catch (std::exception& e) {
25850       {
25851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25852       };
25853     } catch (Dali::DaliException e) {
25854       {
25855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25856       };
25857     } catch (...) {
25858       {
25859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25860       };
25861     }
25862   }
25863
25864   jresult = (int)result;
25865   return jresult;
25866 }
25867
25868
25869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25870   void * jresult ;
25871   Dali::Shader::Hint *result = 0 ;
25872
25873   {
25874     try {
25875       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25876     } catch (std::out_of_range& e) {
25877       {
25878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25879       };
25880     } catch (std::exception& e) {
25881       {
25882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25883       };
25884     } catch (Dali::DaliException e) {
25885       {
25886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25887       };
25888     } catch (...) {
25889       {
25890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25891       };
25892     }
25893   }
25894
25895   jresult = (void *)result;
25896   return jresult;
25897 }
25898
25899
25900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25901   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25902
25903   arg1 = (Dali::Shader::Hint *)jarg1;
25904   {
25905     try {
25906       delete arg1;
25907     } catch (std::out_of_range& e) {
25908       {
25909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25910       };
25911     } catch (std::exception& e) {
25912       {
25913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25914       };
25915     } catch (Dali::DaliException e) {
25916       {
25917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25918       };
25919     } catch (...) {
25920       {
25921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25922       };
25923     }
25924   }
25925
25926 }
25927
25928
25929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25930   int jresult ;
25931   int result;
25932
25933   result = (int)Dali::Shader::Property::PROGRAM;
25934   jresult = (int)result;
25935   return jresult;
25936 }
25937
25938
25939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25940   void * jresult ;
25941   Dali::Shader::Property *result = 0 ;
25942
25943   {
25944     try {
25945       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25946     } catch (std::out_of_range& e) {
25947       {
25948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25949       };
25950     } catch (std::exception& e) {
25951       {
25952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25953       };
25954     } catch (Dali::DaliException e) {
25955       {
25956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25957       };
25958     } catch (...) {
25959       {
25960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25961       };
25962     }
25963   }
25964
25965   jresult = (void *)result;
25966   return jresult;
25967 }
25968
25969
25970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25971   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25972
25973   arg1 = (Dali::Shader::Property *)jarg1;
25974   {
25975     try {
25976       delete arg1;
25977     } catch (std::out_of_range& e) {
25978       {
25979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25980       };
25981     } catch (std::exception& e) {
25982       {
25983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25984       };
25985     } catch (Dali::DaliException e) {
25986       {
25987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25988       };
25989     } catch (...) {
25990       {
25991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25992       };
25993     }
25994   }
25995
25996 }
25997
25998
25999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26000   void * jresult ;
26001   std::string *arg1 = 0 ;
26002   std::string *arg2 = 0 ;
26003   Dali::Shader::Hint::Value arg3 ;
26004   Dali::Shader result;
26005
26006   if (!jarg1) {
26007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26008     return 0;
26009   }
26010   std::string arg1_str(jarg1);
26011   arg1 = &arg1_str;
26012   if (!jarg2) {
26013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26014     return 0;
26015   }
26016   std::string arg2_str(jarg2);
26017   arg2 = &arg2_str;
26018   arg3 = (Dali::Shader::Hint::Value)jarg3;
26019   {
26020     try {
26021       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26022     } catch (std::out_of_range& e) {
26023       {
26024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26025       };
26026     } catch (std::exception& e) {
26027       {
26028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26029       };
26030     } catch (Dali::DaliException e) {
26031       {
26032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26033       };
26034     } catch (...) {
26035       {
26036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26037       };
26038     }
26039   }
26040
26041   jresult = new Dali::Shader((const Dali::Shader &)result);
26042
26043   //argout typemap for const std::string&
26044
26045
26046   //argout typemap for const std::string&
26047
26048   return jresult;
26049 }
26050
26051
26052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26053   void * jresult ;
26054   std::string *arg1 = 0 ;
26055   std::string *arg2 = 0 ;
26056   Dali::Shader result;
26057
26058   if (!jarg1) {
26059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26060     return 0;
26061   }
26062   std::string arg1_str(jarg1);
26063   arg1 = &arg1_str;
26064   if (!jarg2) {
26065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26066     return 0;
26067   }
26068   std::string arg2_str(jarg2);
26069   arg2 = &arg2_str;
26070   {
26071     try {
26072       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26073     } catch (std::out_of_range& e) {
26074       {
26075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26076       };
26077     } catch (std::exception& e) {
26078       {
26079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26080       };
26081     } catch (Dali::DaliException e) {
26082       {
26083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26084       };
26085     } catch (...) {
26086       {
26087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26088       };
26089     }
26090   }
26091
26092   jresult = new Dali::Shader((const Dali::Shader &)result);
26093
26094   //argout typemap for const std::string&
26095
26096
26097   //argout typemap for const std::string&
26098
26099   return jresult;
26100 }
26101
26102
26103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26104   void * jresult ;
26105   Dali::Shader *result = 0 ;
26106
26107   {
26108     try {
26109       result = (Dali::Shader *)new Dali::Shader();
26110     } catch (std::out_of_range& e) {
26111       {
26112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (std::exception& e) {
26115       {
26116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26117       };
26118     } catch (Dali::DaliException e) {
26119       {
26120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26121       };
26122     } catch (...) {
26123       {
26124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26125       };
26126     }
26127   }
26128
26129   jresult = (void *)result;
26130   return jresult;
26131 }
26132
26133
26134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26135   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26136
26137   arg1 = (Dali::Shader *)jarg1;
26138   {
26139     try {
26140       delete arg1;
26141     } catch (std::out_of_range& e) {
26142       {
26143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26144       };
26145     } catch (std::exception& e) {
26146       {
26147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26148       };
26149     } catch (Dali::DaliException e) {
26150       {
26151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26152       };
26153     } catch (...) {
26154       {
26155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26156       };
26157     }
26158   }
26159
26160 }
26161
26162
26163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26164   void * jresult ;
26165   Dali::Shader *arg1 = 0 ;
26166   Dali::Shader *result = 0 ;
26167
26168   arg1 = (Dali::Shader *)jarg1;
26169   if (!arg1) {
26170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26171     return 0;
26172   }
26173   {
26174     try {
26175       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26176     } catch (std::out_of_range& e) {
26177       {
26178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26179       };
26180     } catch (std::exception& e) {
26181       {
26182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26183       };
26184     } catch (Dali::DaliException e) {
26185       {
26186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26187       };
26188     } catch (...) {
26189       {
26190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26191       };
26192     }
26193   }
26194
26195   jresult = (void *)result;
26196   return jresult;
26197 }
26198
26199
26200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26201   void * jresult ;
26202   Dali::BaseHandle arg1 ;
26203   Dali::BaseHandle *argp1 ;
26204   Dali::Shader result;
26205
26206   argp1 = (Dali::BaseHandle *)jarg1;
26207   if (!argp1) {
26208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26209     return 0;
26210   }
26211   arg1 = *argp1;
26212   {
26213     try {
26214       result = Dali::Shader::DownCast(arg1);
26215     } catch (std::out_of_range& e) {
26216       {
26217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26218       };
26219     } catch (std::exception& e) {
26220       {
26221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26222       };
26223     } catch (Dali::DaliException e) {
26224       {
26225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26226       };
26227     } catch (...) {
26228       {
26229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26230       };
26231     }
26232   }
26233
26234   jresult = new Dali::Shader((const Dali::Shader &)result);
26235   return jresult;
26236 }
26237
26238
26239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26240   void * jresult ;
26241   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26242   Dali::Shader *arg2 = 0 ;
26243   Dali::Shader *result = 0 ;
26244
26245   arg1 = (Dali::Shader *)jarg1;
26246   arg2 = (Dali::Shader *)jarg2;
26247   if (!arg2) {
26248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26249     return 0;
26250   }
26251   {
26252     try {
26253       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26254     } catch (std::out_of_range& e) {
26255       {
26256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (std::exception& e) {
26259       {
26260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26261       };
26262     } catch (Dali::DaliException e) {
26263       {
26264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26265       };
26266     } catch (...) {
26267       {
26268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26269       };
26270     }
26271   }
26272
26273   jresult = (void *)result;
26274   return jresult;
26275 }
26276
26277
26278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26279   int jresult ;
26280   int result;
26281
26282   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26283   jresult = (int)result;
26284   return jresult;
26285 }
26286
26287
26288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26289   int jresult ;
26290   int result;
26291
26292   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26293   jresult = (int)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26299   int jresult ;
26300   int result;
26301
26302   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26303   jresult = (int)result;
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26309   int jresult ;
26310   int result;
26311
26312   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26313   jresult = (int)result;
26314   return jresult;
26315 }
26316
26317
26318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26319   int jresult ;
26320   int result;
26321
26322   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26323   jresult = (int)result;
26324   return jresult;
26325 }
26326
26327
26328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26329   int jresult ;
26330   int result;
26331
26332   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26333   jresult = (int)result;
26334   return jresult;
26335 }
26336
26337
26338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26339   int jresult ;
26340   int result;
26341
26342   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26343   jresult = (int)result;
26344   return jresult;
26345 }
26346
26347
26348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26349   int jresult ;
26350   int result;
26351
26352   result = (int)Dali::Renderer::Property::BLEND_MODE;
26353   jresult = (int)result;
26354   return jresult;
26355 }
26356
26357
26358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26359   int jresult ;
26360   int result;
26361
26362   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26363   jresult = (int)result;
26364   return jresult;
26365 }
26366
26367
26368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26369   int jresult ;
26370   int result;
26371
26372   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26373   jresult = (int)result;
26374   return jresult;
26375 }
26376
26377
26378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26379   int jresult ;
26380   int result;
26381
26382   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26383   jresult = (int)result;
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26389   int jresult ;
26390   int result;
26391
26392   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26393   jresult = (int)result;
26394   return jresult;
26395 }
26396
26397
26398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26399   int jresult ;
26400   int result;
26401
26402   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26403   jresult = (int)result;
26404   return jresult;
26405 }
26406
26407
26408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26409   int jresult ;
26410   int result;
26411
26412   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26413   jresult = (int)result;
26414   return jresult;
26415 }
26416
26417
26418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26419   int jresult ;
26420   int result;
26421
26422   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26423   jresult = (int)result;
26424   return jresult;
26425 }
26426
26427
26428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26429   int jresult ;
26430   int result;
26431
26432   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26433   jresult = (int)result;
26434   return jresult;
26435 }
26436
26437
26438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26439   int jresult ;
26440   int result;
26441
26442   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26443   jresult = (int)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26449   int jresult ;
26450   int result;
26451
26452   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26453   jresult = (int)result;
26454   return jresult;
26455 }
26456
26457
26458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26459   int jresult ;
26460   int result;
26461
26462   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26463   jresult = (int)result;
26464   return jresult;
26465 }
26466
26467
26468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26469   int jresult ;
26470   int result;
26471
26472   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26473   jresult = (int)result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26479   int jresult ;
26480   int result;
26481
26482   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26483   jresult = (int)result;
26484   return jresult;
26485 }
26486
26487
26488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26489   int jresult ;
26490   int result;
26491
26492   result = (int)Dali::Renderer::Property::RENDER_MODE;
26493   jresult = (int)result;
26494   return jresult;
26495 }
26496
26497
26498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26499   int jresult ;
26500   int result;
26501
26502   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26503   jresult = (int)result;
26504   return jresult;
26505 }
26506
26507
26508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26509   int jresult ;
26510   int result;
26511
26512   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26513   jresult = (int)result;
26514   return jresult;
26515 }
26516
26517
26518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26519   int jresult ;
26520   int result;
26521
26522   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26523   jresult = (int)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26529   int jresult ;
26530   int result;
26531
26532   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26533   jresult = (int)result;
26534   return jresult;
26535 }
26536
26537
26538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26539   int jresult ;
26540   int result;
26541
26542   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26543   jresult = (int)result;
26544   return jresult;
26545 }
26546
26547
26548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26549   int jresult ;
26550   int result;
26551
26552   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26553   jresult = (int)result;
26554   return jresult;
26555 }
26556
26557
26558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26559   int jresult ;
26560   int result;
26561
26562   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26563   jresult = (int)result;
26564   return jresult;
26565 }
26566
26567
26568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26569   void * jresult ;
26570   Dali::Renderer::Property *result = 0 ;
26571
26572   {
26573     try {
26574       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26575     } catch (std::out_of_range& e) {
26576       {
26577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26578       };
26579     } catch (std::exception& e) {
26580       {
26581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (Dali::DaliException e) {
26584       {
26585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26586       };
26587     } catch (...) {
26588       {
26589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26590       };
26591     }
26592   }
26593
26594   jresult = (void *)result;
26595   return jresult;
26596 }
26597
26598
26599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26600   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26601
26602   arg1 = (Dali::Renderer::Property *)jarg1;
26603   {
26604     try {
26605       delete arg1;
26606     } catch (std::out_of_range& e) {
26607       {
26608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26609       };
26610     } catch (std::exception& e) {
26611       {
26612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26613       };
26614     } catch (Dali::DaliException e) {
26615       {
26616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26617       };
26618     } catch (...) {
26619       {
26620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26621       };
26622     }
26623   }
26624
26625 }
26626
26627
26628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26629   void * jresult ;
26630   Dali::Geometry *arg1 = 0 ;
26631   Dali::Shader *arg2 = 0 ;
26632   Dali::Renderer result;
26633
26634   arg1 = (Dali::Geometry *)jarg1;
26635   if (!arg1) {
26636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26637     return 0;
26638   }
26639   arg2 = (Dali::Shader *)jarg2;
26640   if (!arg2) {
26641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26642     return 0;
26643   }
26644   {
26645     try {
26646       result = Dali::Renderer::New(*arg1,*arg2);
26647     } catch (std::out_of_range& e) {
26648       {
26649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26650       };
26651     } catch (std::exception& e) {
26652       {
26653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26654       };
26655     } catch (Dali::DaliException e) {
26656       {
26657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26658       };
26659     } catch (...) {
26660       {
26661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26662       };
26663     }
26664   }
26665
26666   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26672   void * jresult ;
26673   Dali::Renderer *result = 0 ;
26674
26675   {
26676     try {
26677       result = (Dali::Renderer *)new Dali::Renderer();
26678     } catch (std::out_of_range& e) {
26679       {
26680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26681       };
26682     } catch (std::exception& e) {
26683       {
26684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26685       };
26686     } catch (Dali::DaliException e) {
26687       {
26688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26689       };
26690     } catch (...) {
26691       {
26692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26693       };
26694     }
26695   }
26696
26697   jresult = (void *)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26703   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26704
26705   arg1 = (Dali::Renderer *)jarg1;
26706   {
26707     try {
26708       delete arg1;
26709     } catch (std::out_of_range& e) {
26710       {
26711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26712       };
26713     } catch (std::exception& e) {
26714       {
26715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26716       };
26717     } catch (Dali::DaliException e) {
26718       {
26719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26720       };
26721     } catch (...) {
26722       {
26723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26724       };
26725     }
26726   }
26727
26728 }
26729
26730
26731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26732   void * jresult ;
26733   Dali::Renderer *arg1 = 0 ;
26734   Dali::Renderer *result = 0 ;
26735
26736   arg1 = (Dali::Renderer *)jarg1;
26737   if (!arg1) {
26738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26739     return 0;
26740   }
26741   {
26742     try {
26743       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26744     } catch (std::out_of_range& e) {
26745       {
26746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26747       };
26748     } catch (std::exception& e) {
26749       {
26750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26751       };
26752     } catch (Dali::DaliException e) {
26753       {
26754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26755       };
26756     } catch (...) {
26757       {
26758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26759       };
26760     }
26761   }
26762
26763   jresult = (void *)result;
26764   return jresult;
26765 }
26766
26767
26768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26769   void * jresult ;
26770   Dali::BaseHandle arg1 ;
26771   Dali::BaseHandle *argp1 ;
26772   Dali::Renderer result;
26773
26774   argp1 = (Dali::BaseHandle *)jarg1;
26775   if (!argp1) {
26776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26777     return 0;
26778   }
26779   arg1 = *argp1;
26780   {
26781     try {
26782       result = Dali::Renderer::DownCast(arg1);
26783     } catch (std::out_of_range& e) {
26784       {
26785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26786       };
26787     } catch (std::exception& e) {
26788       {
26789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26790       };
26791     } catch (Dali::DaliException e) {
26792       {
26793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26794       };
26795     } catch (...) {
26796       {
26797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26798       };
26799     }
26800   }
26801
26802   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26803   return jresult;
26804 }
26805
26806
26807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26808   void * jresult ;
26809   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26810   Dali::Renderer *arg2 = 0 ;
26811   Dali::Renderer *result = 0 ;
26812
26813   arg1 = (Dali::Renderer *)jarg1;
26814   arg2 = (Dali::Renderer *)jarg2;
26815   if (!arg2) {
26816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26817     return 0;
26818   }
26819   {
26820     try {
26821       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26822     } catch (std::out_of_range& e) {
26823       {
26824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26825       };
26826     } catch (std::exception& e) {
26827       {
26828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26829       };
26830     } catch (Dali::DaliException e) {
26831       {
26832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26833       };
26834     } catch (...) {
26835       {
26836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26837       };
26838     }
26839   }
26840
26841   jresult = (void *)result;
26842   return jresult;
26843 }
26844
26845
26846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26847   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26848   Dali::Geometry *arg2 = 0 ;
26849
26850   arg1 = (Dali::Renderer *)jarg1;
26851   arg2 = (Dali::Geometry *)jarg2;
26852   if (!arg2) {
26853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26854     return ;
26855   }
26856   {
26857     try {
26858       (arg1)->SetGeometry(*arg2);
26859     } catch (std::out_of_range& e) {
26860       {
26861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26862       };
26863     } catch (std::exception& e) {
26864       {
26865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26866       };
26867     } catch (Dali::DaliException e) {
26868       {
26869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26870       };
26871     } catch (...) {
26872       {
26873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26874       };
26875     }
26876   }
26877
26878 }
26879
26880
26881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26882   void * jresult ;
26883   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26884   Dali::Geometry result;
26885
26886   arg1 = (Dali::Renderer *)jarg1;
26887   {
26888     try {
26889       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26890     } catch (std::out_of_range& e) {
26891       {
26892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26893       };
26894     } catch (std::exception& e) {
26895       {
26896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26897       };
26898     } catch (Dali::DaliException e) {
26899       {
26900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26901       };
26902     } catch (...) {
26903       {
26904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26905       };
26906     }
26907   }
26908
26909   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26910   return jresult;
26911 }
26912
26913
26914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26915   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26916   int arg2 ;
26917   int arg3 ;
26918
26919   arg1 = (Dali::Renderer *)jarg1;
26920   arg2 = (int)jarg2;
26921   arg3 = (int)jarg3;
26922   {
26923     try {
26924       (arg1)->SetIndexRange(arg2,arg3);
26925     } catch (std::out_of_range& e) {
26926       {
26927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26928       };
26929     } catch (std::exception& e) {
26930       {
26931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26932       };
26933     } catch (Dali::DaliException e) {
26934       {
26935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26936       };
26937     } catch (...) {
26938       {
26939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26940       };
26941     }
26942   }
26943
26944 }
26945
26946
26947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26948   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26949   Dali::TextureSet *arg2 = 0 ;
26950
26951   arg1 = (Dali::Renderer *)jarg1;
26952   arg2 = (Dali::TextureSet *)jarg2;
26953   if (!arg2) {
26954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26955     return ;
26956   }
26957   {
26958     try {
26959       (arg1)->SetTextures(*arg2);
26960     } catch (std::out_of_range& e) {
26961       {
26962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26963       };
26964     } catch (std::exception& e) {
26965       {
26966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26967       };
26968     } catch (Dali::DaliException e) {
26969       {
26970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26971       };
26972     } catch (...) {
26973       {
26974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26975       };
26976     }
26977   }
26978
26979 }
26980
26981
26982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26983   void * jresult ;
26984   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26985   Dali::TextureSet result;
26986
26987   arg1 = (Dali::Renderer *)jarg1;
26988   {
26989     try {
26990       result = ((Dali::Renderer const *)arg1)->GetTextures();
26991     } catch (std::out_of_range& e) {
26992       {
26993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26994       };
26995     } catch (std::exception& e) {
26996       {
26997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26998       };
26999     } catch (Dali::DaliException e) {
27000       {
27001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27002       };
27003     } catch (...) {
27004       {
27005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27006       };
27007     }
27008   }
27009
27010   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27011   return jresult;
27012 }
27013
27014
27015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27016   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27017   Dali::Shader *arg2 = 0 ;
27018
27019   arg1 = (Dali::Renderer *)jarg1;
27020   arg2 = (Dali::Shader *)jarg2;
27021   if (!arg2) {
27022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27023     return ;
27024   }
27025   {
27026     try {
27027       (arg1)->SetShader(*arg2);
27028     } catch (std::out_of_range& e) {
27029       {
27030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27031       };
27032     } catch (std::exception& e) {
27033       {
27034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27035       };
27036     } catch (Dali::DaliException e) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27039       };
27040     } catch (...) {
27041       {
27042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27043       };
27044     }
27045   }
27046
27047 }
27048
27049
27050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27051   void * jresult ;
27052   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27053   Dali::Shader result;
27054
27055   arg1 = (Dali::Renderer *)jarg1;
27056   {
27057     try {
27058       result = ((Dali::Renderer const *)arg1)->GetShader();
27059     } catch (std::out_of_range& e) {
27060       {
27061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27062       };
27063     } catch (std::exception& e) {
27064       {
27065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27066       };
27067     } catch (Dali::DaliException e) {
27068       {
27069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27070       };
27071     } catch (...) {
27072       {
27073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27074       };
27075     }
27076   }
27077
27078   jresult = new Dali::Shader((const Dali::Shader &)result);
27079   return jresult;
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27084   void * jresult ;
27085   Dali::FrameBuffer::Attachment *result = 0 ;
27086
27087   {
27088     try {
27089       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27090     } catch (std::out_of_range& e) {
27091       {
27092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27093       };
27094     } catch (std::exception& e) {
27095       {
27096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27097       };
27098     } catch (Dali::DaliException e) {
27099       {
27100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27101       };
27102     } catch (...) {
27103       {
27104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27105       };
27106     }
27107   }
27108
27109   jresult = (void *)result;
27110   return jresult;
27111 }
27112
27113
27114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27115   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27116
27117   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27118   {
27119     try {
27120       delete arg1;
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27128       };
27129     } catch (Dali::DaliException e) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27132       };
27133     } catch (...) {
27134       {
27135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27136       };
27137     }
27138   }
27139
27140 }
27141
27142
27143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27144   void * jresult ;
27145   unsigned int arg1 ;
27146   unsigned int arg2 ;
27147   unsigned int arg3 ;
27148   Dali::FrameBuffer result;
27149
27150   arg1 = (unsigned int)jarg1;
27151   arg2 = (unsigned int)jarg2;
27152   arg3 = (unsigned int)jarg3;
27153   {
27154     try {
27155       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27156     } catch (std::out_of_range& e) {
27157       {
27158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (std::exception& e) {
27161       {
27162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27163       };
27164     } catch (Dali::DaliException e) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27167       };
27168     } catch (...) {
27169       {
27170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27171       };
27172     }
27173   }
27174
27175   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27176   return jresult;
27177 }
27178
27179
27180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27181   void * jresult ;
27182   Dali::FrameBuffer *result = 0 ;
27183
27184   {
27185     try {
27186       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27202       };
27203     }
27204   }
27205
27206   jresult = (void *)result;
27207   return jresult;
27208 }
27209
27210
27211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27212   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27213
27214   arg1 = (Dali::FrameBuffer *)jarg1;
27215   {
27216     try {
27217       delete arg1;
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27225       };
27226     } catch (Dali::DaliException e) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27229       };
27230     } catch (...) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27233       };
27234     }
27235   }
27236
27237 }
27238
27239
27240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27241   void * jresult ;
27242   Dali::FrameBuffer *arg1 = 0 ;
27243   Dali::FrameBuffer *result = 0 ;
27244
27245   arg1 = (Dali::FrameBuffer *)jarg1;
27246   if (!arg1) {
27247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27248     return 0;
27249   }
27250   {
27251     try {
27252       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271
27272   jresult = (void *)result;
27273   return jresult;
27274 }
27275
27276
27277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27278   void * jresult ;
27279   Dali::BaseHandle arg1 ;
27280   Dali::BaseHandle *argp1 ;
27281   Dali::FrameBuffer result;
27282
27283   argp1 = (Dali::BaseHandle *)jarg1;
27284   if (!argp1) {
27285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27286     return 0;
27287   }
27288   arg1 = *argp1;
27289   {
27290     try {
27291       result = Dali::FrameBuffer::DownCast(arg1);
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27307       };
27308     }
27309   }
27310
27311   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27317   void * jresult ;
27318   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27319   Dali::FrameBuffer *arg2 = 0 ;
27320   Dali::FrameBuffer *result = 0 ;
27321
27322   arg1 = (Dali::FrameBuffer *)jarg1;
27323   arg2 = (Dali::FrameBuffer *)jarg2;
27324   if (!arg2) {
27325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27326     return 0;
27327   }
27328   {
27329     try {
27330       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27331     } catch (std::out_of_range& e) {
27332       {
27333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27334       };
27335     } catch (std::exception& e) {
27336       {
27337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27338       };
27339     } catch (Dali::DaliException e) {
27340       {
27341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27342       };
27343     } catch (...) {
27344       {
27345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27346       };
27347     }
27348   }
27349
27350   jresult = (void *)result;
27351   return jresult;
27352 }
27353
27354
27355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27356   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27357   Dali::Texture *arg2 = 0 ;
27358
27359   arg1 = (Dali::FrameBuffer *)jarg1;
27360   arg2 = (Dali::Texture *)jarg2;
27361   if (!arg2) {
27362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27363     return ;
27364   }
27365   {
27366     try {
27367       (arg1)->AttachColorTexture(*arg2);
27368     } catch (std::out_of_range& e) {
27369       {
27370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27371       };
27372     } catch (std::exception& e) {
27373       {
27374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27375       };
27376     } catch (Dali::DaliException e) {
27377       {
27378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27379       };
27380     } catch (...) {
27381       {
27382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27383       };
27384     }
27385   }
27386
27387 }
27388
27389
27390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27391   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27392   Dali::Texture *arg2 = 0 ;
27393   unsigned int arg3 ;
27394   unsigned int arg4 ;
27395
27396   arg1 = (Dali::FrameBuffer *)jarg1;
27397   arg2 = (Dali::Texture *)jarg2;
27398   if (!arg2) {
27399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27400     return ;
27401   }
27402   arg3 = (unsigned int)jarg3;
27403   arg4 = (unsigned int)jarg4;
27404   {
27405     try {
27406       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27407     } catch (std::out_of_range& e) {
27408       {
27409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27410       };
27411     } catch (std::exception& e) {
27412       {
27413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27414       };
27415     } catch (Dali::DaliException e) {
27416       {
27417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27418       };
27419     } catch (...) {
27420       {
27421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27422       };
27423     }
27424   }
27425
27426 }
27427
27428
27429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27430   void * jresult ;
27431   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27432   Dali::Texture result;
27433
27434   arg1 = (Dali::FrameBuffer *)jarg1;
27435   {
27436     try {
27437       result = (arg1)->GetColorTexture();
27438     } catch (std::out_of_range& e) {
27439       {
27440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27441       };
27442     } catch (std::exception& e) {
27443       {
27444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27445       };
27446     } catch (Dali::DaliException e) {
27447       {
27448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27449       };
27450     } catch (...) {
27451       {
27452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27453       };
27454     }
27455   }
27456
27457   jresult = new Dali::Texture((const Dali::Texture &)result);
27458   return jresult;
27459 }
27460
27461
27462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27463   void * jresult ;
27464   Dali::RenderTaskList *result = 0 ;
27465
27466   {
27467     try {
27468       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27469     } catch (std::out_of_range& e) {
27470       {
27471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27472       };
27473     } catch (std::exception& e) {
27474       {
27475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27476       };
27477     } catch (Dali::DaliException e) {
27478       {
27479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27480       };
27481     } catch (...) {
27482       {
27483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27484       };
27485     }
27486   }
27487
27488   jresult = (void *)result;
27489   return jresult;
27490 }
27491
27492
27493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27494   void * jresult ;
27495   Dali::BaseHandle arg1 ;
27496   Dali::BaseHandle *argp1 ;
27497   Dali::RenderTaskList result;
27498
27499   argp1 = (Dali::BaseHandle *)jarg1;
27500   if (!argp1) {
27501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27502     return 0;
27503   }
27504   arg1 = *argp1;
27505   {
27506     try {
27507       result = Dali::RenderTaskList::DownCast(arg1);
27508     } catch (std::out_of_range& e) {
27509       {
27510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27511       };
27512     } catch (std::exception& e) {
27513       {
27514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27515       };
27516     } catch (Dali::DaliException e) {
27517       {
27518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27519       };
27520     } catch (...) {
27521       {
27522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27523       };
27524     }
27525   }
27526
27527   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27528   return jresult;
27529 }
27530
27531
27532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27533   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27534
27535   arg1 = (Dali::RenderTaskList *)jarg1;
27536   {
27537     try {
27538       delete arg1;
27539     } catch (std::out_of_range& e) {
27540       {
27541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27542       };
27543     } catch (std::exception& e) {
27544       {
27545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27546       };
27547     } catch (Dali::DaliException e) {
27548       {
27549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27550       };
27551     } catch (...) {
27552       {
27553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27554       };
27555     }
27556   }
27557
27558 }
27559
27560
27561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27562   void * jresult ;
27563   Dali::RenderTaskList *arg1 = 0 ;
27564   Dali::RenderTaskList *result = 0 ;
27565
27566   arg1 = (Dali::RenderTaskList *)jarg1;
27567   if (!arg1) {
27568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27569     return 0;
27570   }
27571   {
27572     try {
27573       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27574     } catch (std::out_of_range& e) {
27575       {
27576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27577       };
27578     } catch (std::exception& e) {
27579       {
27580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27581       };
27582     } catch (Dali::DaliException e) {
27583       {
27584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27585       };
27586     } catch (...) {
27587       {
27588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27589       };
27590     }
27591   }
27592
27593   jresult = (void *)result;
27594   return jresult;
27595 }
27596
27597
27598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27599   void * jresult ;
27600   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27601   Dali::RenderTaskList *arg2 = 0 ;
27602   Dali::RenderTaskList *result = 0 ;
27603
27604   arg1 = (Dali::RenderTaskList *)jarg1;
27605   arg2 = (Dali::RenderTaskList *)jarg2;
27606   if (!arg2) {
27607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27608     return 0;
27609   }
27610   {
27611     try {
27612       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27613     } catch (std::out_of_range& e) {
27614       {
27615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27616       };
27617     } catch (std::exception& e) {
27618       {
27619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27620       };
27621     } catch (Dali::DaliException e) {
27622       {
27623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27624       };
27625     } catch (...) {
27626       {
27627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27628       };
27629     }
27630   }
27631
27632   jresult = (void *)result;
27633   return jresult;
27634 }
27635
27636
27637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27638   void * jresult ;
27639   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27640   Dali::RenderTask result;
27641
27642   arg1 = (Dali::RenderTaskList *)jarg1;
27643   {
27644     try {
27645       result = (arg1)->CreateTask();
27646     } catch (std::out_of_range& e) {
27647       {
27648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27649       };
27650     } catch (std::exception& e) {
27651       {
27652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27653       };
27654     } catch (Dali::DaliException e) {
27655       {
27656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27657       };
27658     } catch (...) {
27659       {
27660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27661       };
27662     }
27663   }
27664
27665   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27671   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27672   Dali::RenderTask arg2 ;
27673   Dali::RenderTask *argp2 ;
27674
27675   arg1 = (Dali::RenderTaskList *)jarg1;
27676   argp2 = (Dali::RenderTask *)jarg2;
27677   if (!argp2) {
27678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27679     return ;
27680   }
27681   arg2 = *argp2;
27682   {
27683     try {
27684       (arg1)->RemoveTask(arg2);
27685     } catch (std::out_of_range& e) {
27686       {
27687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27688       };
27689     } catch (std::exception& e) {
27690       {
27691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27692       };
27693     } catch (Dali::DaliException e) {
27694       {
27695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27696       };
27697     } catch (...) {
27698       {
27699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27700       };
27701     }
27702   }
27703
27704 }
27705
27706
27707 //// ===============================================end part 1 =================
27708
27709 //// ========================= part 2 ===============================
27710
27711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27712   unsigned int jresult ;
27713   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27714   unsigned int result;
27715
27716   arg1 = (Dali::RenderTaskList *)jarg1;
27717   {
27718     try {
27719       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27720     } catch (std::out_of_range& e) {
27721       {
27722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27723       };
27724     } catch (std::exception& e) {
27725       {
27726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27727       };
27728     } catch (Dali::DaliException e) {
27729       {
27730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27731       };
27732     } catch (...) {
27733       {
27734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27735       };
27736     }
27737   }
27738
27739   jresult = result;
27740   return jresult;
27741 }
27742
27743
27744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27745   void * jresult ;
27746   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27747   unsigned int arg2 ;
27748   Dali::RenderTask result;
27749
27750   arg1 = (Dali::RenderTaskList *)jarg1;
27751   arg2 = (unsigned int)jarg2;
27752   {
27753     try {
27754       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27755     } catch (std::out_of_range& e) {
27756       {
27757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27758       };
27759     } catch (std::exception& e) {
27760       {
27761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27762       };
27763     } catch (Dali::DaliException e) {
27764       {
27765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27766       };
27767     } catch (...) {
27768       {
27769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27770       };
27771     }
27772   }
27773
27774   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27775   return jresult;
27776 }
27777
27778
27779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27780   int jresult ;
27781   int result;
27782
27783   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27784   jresult = (int)result;
27785   return jresult;
27786 }
27787
27788
27789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27790   int jresult ;
27791   int result;
27792
27793   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27794   jresult = (int)result;
27795   return jresult;
27796 }
27797
27798
27799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27800   int jresult ;
27801   int result;
27802
27803   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27804   jresult = (int)result;
27805   return jresult;
27806 }
27807
27808
27809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27810   int jresult ;
27811   int result;
27812
27813   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27814   jresult = (int)result;
27815   return jresult;
27816 }
27817
27818
27819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27820   void * jresult ;
27821   Dali::RenderTask::Property *result = 0 ;
27822
27823   {
27824     try {
27825       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27826     } catch (std::out_of_range& e) {
27827       {
27828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27829       };
27830     } catch (std::exception& e) {
27831       {
27832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (Dali::DaliException e) {
27835       {
27836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27837       };
27838     } catch (...) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27841       };
27842     }
27843   }
27844
27845   jresult = (void *)result;
27846   return jresult;
27847 }
27848
27849
27850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27851   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27852
27853   arg1 = (Dali::RenderTask::Property *)jarg1;
27854   {
27855     try {
27856       delete arg1;
27857     } catch (std::out_of_range& e) {
27858       {
27859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27860       };
27861     } catch (std::exception& e) {
27862       {
27863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27864       };
27865     } catch (Dali::DaliException e) {
27866       {
27867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27868       };
27869     } catch (...) {
27870       {
27871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27872       };
27873     }
27874   }
27875
27876 }
27877
27878
27879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27880   void * jresult ;
27881   bool (*result)(Dali::Vector2 &) = 0 ;
27882
27883   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27884   jresult = (void *)result;
27885   return jresult;
27886 }
27887
27888
27889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27890   void * jresult ;
27891   bool (*result)(Dali::Vector2 &) = 0 ;
27892
27893   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27900   unsigned int jresult ;
27901   bool result;
27902
27903   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27904   jresult = result;
27905   return jresult;
27906 }
27907
27908
27909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27910   unsigned int jresult ;
27911   bool result;
27912
27913   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27914   jresult = result;
27915   return jresult;
27916 }
27917
27918
27919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27920   void * jresult ;
27921   Dali::Vector4 *result = 0 ;
27922
27923   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27924   jresult = (void *)result;
27925   return jresult;
27926 }
27927
27928
27929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27930   unsigned int jresult ;
27931   bool result;
27932
27933   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27934   jresult = result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27940   unsigned int jresult ;
27941   bool result;
27942
27943   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27944   jresult = result;
27945   return jresult;
27946 }
27947
27948
27949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27950   unsigned int jresult ;
27951   unsigned int result;
27952
27953   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27954   jresult = result;
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27960   void * jresult ;
27961   Dali::RenderTask *result = 0 ;
27962
27963   {
27964     try {
27965       result = (Dali::RenderTask *)new Dali::RenderTask();
27966     } catch (std::out_of_range& e) {
27967       {
27968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27969       };
27970     } catch (std::exception& e) {
27971       {
27972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27973       };
27974     } catch (Dali::DaliException e) {
27975       {
27976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27977       };
27978     } catch (...) {
27979       {
27980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27981       };
27982     }
27983   }
27984
27985   jresult = (void *)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27991   void * jresult ;
27992   Dali::BaseHandle arg1 ;
27993   Dali::BaseHandle *argp1 ;
27994   Dali::RenderTask result;
27995
27996   argp1 = (Dali::BaseHandle *)jarg1;
27997   if (!argp1) {
27998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27999     return 0;
28000   }
28001   arg1 = *argp1;
28002   {
28003     try {
28004       result = Dali::RenderTask::DownCast(arg1);
28005     } catch (std::out_of_range& e) {
28006       {
28007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28008       };
28009     } catch (std::exception& e) {
28010       {
28011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (Dali::DaliException e) {
28014       {
28015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28016       };
28017     } catch (...) {
28018       {
28019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28020       };
28021     }
28022   }
28023
28024   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28025   return jresult;
28026 }
28027
28028
28029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28030   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28031
28032   arg1 = (Dali::RenderTask *)jarg1;
28033   {
28034     try {
28035       delete arg1;
28036     } catch (std::out_of_range& e) {
28037       {
28038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28039       };
28040     } catch (std::exception& e) {
28041       {
28042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28043       };
28044     } catch (Dali::DaliException e) {
28045       {
28046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28047       };
28048     } catch (...) {
28049       {
28050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28051       };
28052     }
28053   }
28054
28055 }
28056
28057
28058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28059   void * jresult ;
28060   Dali::RenderTask *arg1 = 0 ;
28061   Dali::RenderTask *result = 0 ;
28062
28063   arg1 = (Dali::RenderTask *)jarg1;
28064   if (!arg1) {
28065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28066     return 0;
28067   }
28068   {
28069     try {
28070       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28071     } catch (std::out_of_range& e) {
28072       {
28073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28074       };
28075     } catch (std::exception& e) {
28076       {
28077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28078       };
28079     } catch (Dali::DaliException e) {
28080       {
28081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28082       };
28083     } catch (...) {
28084       {
28085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28086       };
28087     }
28088   }
28089
28090   jresult = (void *)result;
28091   return jresult;
28092 }
28093
28094
28095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28096   void * jresult ;
28097   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28098   Dali::RenderTask *arg2 = 0 ;
28099   Dali::RenderTask *result = 0 ;
28100
28101   arg1 = (Dali::RenderTask *)jarg1;
28102   arg2 = (Dali::RenderTask *)jarg2;
28103   if (!arg2) {
28104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28105     return 0;
28106   }
28107   {
28108     try {
28109       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28110     } catch (std::out_of_range& e) {
28111       {
28112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28113       };
28114     } catch (std::exception& e) {
28115       {
28116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28117       };
28118     } catch (Dali::DaliException e) {
28119       {
28120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28121       };
28122     } catch (...) {
28123       {
28124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28125       };
28126     }
28127   }
28128
28129   jresult = (void *)result;
28130   return jresult;
28131 }
28132
28133
28134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28135   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28136   Dali::Actor arg2 ;
28137   Dali::Actor *argp2 ;
28138
28139   arg1 = (Dali::RenderTask *)jarg1;
28140   argp2 = (Dali::Actor *)jarg2;
28141   if (!argp2) {
28142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28143     return ;
28144   }
28145   arg2 = *argp2;
28146   {
28147     try {
28148       (arg1)->SetSourceActor(arg2);
28149     } catch (std::out_of_range& e) {
28150       {
28151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28152       };
28153     } catch (std::exception& e) {
28154       {
28155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28156       };
28157     } catch (Dali::DaliException e) {
28158       {
28159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28160       };
28161     } catch (...) {
28162       {
28163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28164       };
28165     }
28166   }
28167
28168 }
28169
28170
28171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28172   void * jresult ;
28173   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28174   Dali::Actor result;
28175
28176   arg1 = (Dali::RenderTask *)jarg1;
28177   {
28178     try {
28179       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28180     } catch (std::out_of_range& e) {
28181       {
28182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28183       };
28184     } catch (std::exception& e) {
28185       {
28186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28187       };
28188     } catch (Dali::DaliException e) {
28189       {
28190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28191       };
28192     } catch (...) {
28193       {
28194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28195       };
28196     }
28197   }
28198
28199   jresult = new Dali::Actor((const Dali::Actor &)result);
28200   return jresult;
28201 }
28202
28203
28204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28205   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28206   bool arg2 ;
28207
28208   arg1 = (Dali::RenderTask *)jarg1;
28209   arg2 = jarg2 ? true : false;
28210   {
28211     try {
28212       (arg1)->SetExclusive(arg2);
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28220       };
28221     } catch (Dali::DaliException e) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28224       };
28225     } catch (...) {
28226       {
28227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28228       };
28229     }
28230   }
28231
28232 }
28233
28234
28235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28236   unsigned int jresult ;
28237   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28238   bool result;
28239
28240   arg1 = (Dali::RenderTask *)jarg1;
28241   {
28242     try {
28243       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28244     } catch (std::out_of_range& e) {
28245       {
28246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28247       };
28248     } catch (std::exception& e) {
28249       {
28250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28251       };
28252     } catch (Dali::DaliException e) {
28253       {
28254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28255       };
28256     } catch (...) {
28257       {
28258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28259       };
28260     }
28261   }
28262
28263   jresult = result;
28264   return jresult;
28265 }
28266
28267
28268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28269   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28270   bool arg2 ;
28271
28272   arg1 = (Dali::RenderTask *)jarg1;
28273   arg2 = jarg2 ? true : false;
28274   {
28275     try {
28276       (arg1)->SetInputEnabled(arg2);
28277     } catch (std::out_of_range& e) {
28278       {
28279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28280       };
28281     } catch (std::exception& e) {
28282       {
28283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28284       };
28285     } catch (Dali::DaliException e) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28288       };
28289     } catch (...) {
28290       {
28291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28292       };
28293     }
28294   }
28295
28296 }
28297
28298
28299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28300   unsigned int jresult ;
28301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28302   bool result;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   {
28306     try {
28307       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28308     } catch (std::out_of_range& e) {
28309       {
28310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28311       };
28312     } catch (std::exception& e) {
28313       {
28314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (Dali::DaliException e) {
28317       {
28318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28319       };
28320     } catch (...) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28323       };
28324     }
28325   }
28326
28327   jresult = result;
28328   return jresult;
28329 }
28330
28331
28332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28333   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28334   Dali::CameraActor arg2 ;
28335   Dali::CameraActor *argp2 ;
28336
28337   arg1 = (Dali::RenderTask *)jarg1;
28338   argp2 = (Dali::CameraActor *)jarg2;
28339   if (!argp2) {
28340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28341     return ;
28342   }
28343   arg2 = *argp2;
28344   {
28345     try {
28346       (arg1)->SetCameraActor(arg2);
28347     } catch (std::out_of_range& e) {
28348       {
28349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28350       };
28351     } catch (std::exception& e) {
28352       {
28353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (Dali::DaliException e) {
28356       {
28357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28358       };
28359     } catch (...) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28362       };
28363     }
28364   }
28365
28366 }
28367
28368
28369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28370   void * jresult ;
28371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28372   Dali::CameraActor result;
28373
28374   arg1 = (Dali::RenderTask *)jarg1;
28375   {
28376     try {
28377       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28378     } catch (std::out_of_range& e) {
28379       {
28380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28381       };
28382     } catch (std::exception& e) {
28383       {
28384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (Dali::DaliException e) {
28387       {
28388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28389       };
28390     } catch (...) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28393       };
28394     }
28395   }
28396
28397   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28398   return jresult;
28399 }
28400
28401
28402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28403   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28404   Dali::FrameBuffer arg2 ;
28405   Dali::FrameBuffer *argp2 ;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   argp2 = (Dali::FrameBuffer *)jarg2;
28409   if (!argp2) {
28410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28411     return ;
28412   }
28413   arg2 = *argp2;
28414   {
28415     try {
28416       (arg1)->SetFrameBuffer(arg2);
28417     } catch (std::out_of_range& e) {
28418       {
28419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28420       };
28421     } catch (std::exception& e) {
28422       {
28423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28424       };
28425     } catch (Dali::DaliException e) {
28426       {
28427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28428       };
28429     } catch (...) {
28430       {
28431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28432       };
28433     }
28434   }
28435
28436 }
28437
28438
28439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28440   void * jresult ;
28441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28442   Dali::FrameBuffer result;
28443
28444   arg1 = (Dali::RenderTask *)jarg1;
28445   {
28446     try {
28447       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28448     } catch (std::out_of_range& e) {
28449       {
28450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28451       };
28452     } catch (std::exception& e) {
28453       {
28454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28455       };
28456     } catch (Dali::DaliException e) {
28457       {
28458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28459       };
28460     } catch (...) {
28461       {
28462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28463       };
28464     }
28465   }
28466
28467   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28468   return jresult;
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28473   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28474   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28475
28476   arg1 = (Dali::RenderTask *)jarg1;
28477   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28478   {
28479     try {
28480       (arg1)->SetScreenToFrameBufferFunction(arg2);
28481     } catch (std::out_of_range& e) {
28482       {
28483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (std::exception& e) {
28486       {
28487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28488       };
28489     } catch (Dali::DaliException e) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28496       };
28497     }
28498   }
28499
28500 }
28501
28502
28503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28504   void * jresult ;
28505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28506   Dali::RenderTask::ScreenToFrameBufferFunction result;
28507
28508   arg1 = (Dali::RenderTask *)jarg1;
28509   {
28510     try {
28511       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28512     } catch (std::out_of_range& e) {
28513       {
28514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (std::exception& e) {
28517       {
28518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28519       };
28520     } catch (Dali::DaliException e) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28523       };
28524     } catch (...) {
28525       {
28526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28527       };
28528     }
28529   }
28530
28531   jresult = (void *)result;
28532   return jresult;
28533 }
28534
28535
28536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28537   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28538   Dali::Actor arg2 ;
28539   Dali::Actor *argp2 ;
28540
28541   arg1 = (Dali::RenderTask *)jarg1;
28542   argp2 = (Dali::Actor *)jarg2;
28543   if (!argp2) {
28544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28545     return ;
28546   }
28547   arg2 = *argp2;
28548   {
28549     try {
28550       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28551     } catch (std::out_of_range& e) {
28552       {
28553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28554       };
28555     } catch (std::exception& e) {
28556       {
28557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28558       };
28559     } catch (Dali::DaliException e) {
28560       {
28561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28562       };
28563     } catch (...) {
28564       {
28565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28566       };
28567     }
28568   }
28569
28570 }
28571
28572
28573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28574   void * jresult ;
28575   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28576   Dali::Actor result;
28577
28578   arg1 = (Dali::RenderTask *)jarg1;
28579   {
28580     try {
28581       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28582     } catch (std::out_of_range& e) {
28583       {
28584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28585       };
28586     } catch (std::exception& e) {
28587       {
28588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28589       };
28590     } catch (Dali::DaliException e) {
28591       {
28592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28593       };
28594     } catch (...) {
28595       {
28596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28597       };
28598     }
28599   }
28600
28601   jresult = new Dali::Actor((const Dali::Actor &)result);
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28607   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28608   Dali::Vector2 arg2 ;
28609   Dali::Vector2 *argp2 ;
28610
28611   arg1 = (Dali::RenderTask *)jarg1;
28612   argp2 = (Dali::Vector2 *)jarg2;
28613   if (!argp2) {
28614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28615     return ;
28616   }
28617   arg2 = *argp2;
28618   {
28619     try {
28620       (arg1)->SetViewportPosition(arg2);
28621     } catch (std::out_of_range& e) {
28622       {
28623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28624       };
28625     } catch (std::exception& e) {
28626       {
28627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28628       };
28629     } catch (Dali::DaliException e) {
28630       {
28631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28632       };
28633     } catch (...) {
28634       {
28635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28636       };
28637     }
28638   }
28639
28640 }
28641
28642
28643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28644   void * jresult ;
28645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28646   Dali::Vector2 result;
28647
28648   arg1 = (Dali::RenderTask *)jarg1;
28649   {
28650     try {
28651       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28652     } catch (std::out_of_range& e) {
28653       {
28654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28655       };
28656     } catch (std::exception& e) {
28657       {
28658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28659       };
28660     } catch (Dali::DaliException e) {
28661       {
28662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28663       };
28664     } catch (...) {
28665       {
28666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28667       };
28668     }
28669   }
28670
28671   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28672   return jresult;
28673 }
28674
28675
28676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28678   Dali::Vector2 arg2 ;
28679   Dali::Vector2 *argp2 ;
28680
28681   arg1 = (Dali::RenderTask *)jarg1;
28682   argp2 = (Dali::Vector2 *)jarg2;
28683   if (!argp2) {
28684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28685     return ;
28686   }
28687   arg2 = *argp2;
28688   {
28689     try {
28690       (arg1)->SetViewportSize(arg2);
28691     } catch (std::out_of_range& e) {
28692       {
28693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28694       };
28695     } catch (std::exception& e) {
28696       {
28697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28698       };
28699     } catch (Dali::DaliException e) {
28700       {
28701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28702       };
28703     } catch (...) {
28704       {
28705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28706       };
28707     }
28708   }
28709
28710 }
28711
28712
28713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28714   void * jresult ;
28715   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28716   Dali::Vector2 result;
28717
28718   arg1 = (Dali::RenderTask *)jarg1;
28719   {
28720     try {
28721       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28722     } catch (std::out_of_range& e) {
28723       {
28724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28725       };
28726     } catch (std::exception& e) {
28727       {
28728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28729       };
28730     } catch (Dali::DaliException e) {
28731       {
28732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28733       };
28734     } catch (...) {
28735       {
28736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28737       };
28738     }
28739   }
28740
28741   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28742   return jresult;
28743 }
28744
28745
28746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28747   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28748   Dali::Viewport arg2 ;
28749   Dali::Viewport *argp2 ;
28750
28751   arg1 = (Dali::RenderTask *)jarg1;
28752   argp2 = (Dali::Viewport *)jarg2;
28753   if (!argp2) {
28754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28755     return ;
28756   }
28757   arg2 = *argp2;
28758   {
28759     try {
28760       (arg1)->SetViewport(arg2);
28761     } catch (std::out_of_range& e) {
28762       {
28763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28764       };
28765     } catch (std::exception& e) {
28766       {
28767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28768       };
28769     } catch (Dali::DaliException e) {
28770       {
28771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28772       };
28773     } catch (...) {
28774       {
28775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28776       };
28777     }
28778   }
28779
28780 }
28781
28782
28783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28784   void * jresult ;
28785   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28786   Dali::Viewport result;
28787
28788   arg1 = (Dali::RenderTask *)jarg1;
28789   {
28790     try {
28791       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28792     } catch (std::out_of_range& e) {
28793       {
28794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28795       };
28796     } catch (std::exception& e) {
28797       {
28798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28799       };
28800     } catch (Dali::DaliException e) {
28801       {
28802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28803       };
28804     } catch (...) {
28805       {
28806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28807       };
28808     }
28809   }
28810
28811   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28812   return jresult;
28813 }
28814
28815
28816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28817   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28818   Dali::Vector4 *arg2 = 0 ;
28819
28820   arg1 = (Dali::RenderTask *)jarg1;
28821   arg2 = (Dali::Vector4 *)jarg2;
28822   if (!arg2) {
28823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28824     return ;
28825   }
28826   {
28827     try {
28828       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28829     } catch (std::out_of_range& e) {
28830       {
28831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28832       };
28833     } catch (std::exception& e) {
28834       {
28835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28836       };
28837     } catch (Dali::DaliException e) {
28838       {
28839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28840       };
28841     } catch (...) {
28842       {
28843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28844       };
28845     }
28846   }
28847
28848 }
28849
28850
28851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28852   void * jresult ;
28853   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28854   Dali::Vector4 result;
28855
28856   arg1 = (Dali::RenderTask *)jarg1;
28857   {
28858     try {
28859       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28860     } catch (std::out_of_range& e) {
28861       {
28862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28863       };
28864     } catch (std::exception& e) {
28865       {
28866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28867       };
28868     } catch (Dali::DaliException e) {
28869       {
28870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28871       };
28872     } catch (...) {
28873       {
28874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28875       };
28876     }
28877   }
28878
28879   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28885   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28886   bool arg2 ;
28887
28888   arg1 = (Dali::RenderTask *)jarg1;
28889   arg2 = jarg2 ? true : false;
28890   {
28891     try {
28892       (arg1)->SetClearEnabled(arg2);
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28908       };
28909     }
28910   }
28911
28912 }
28913
28914
28915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28916   unsigned int jresult ;
28917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28918   bool result;
28919
28920   arg1 = (Dali::RenderTask *)jarg1;
28921   {
28922     try {
28923       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28924     } catch (std::out_of_range& e) {
28925       {
28926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (std::exception& e) {
28929       {
28930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28931       };
28932     } catch (Dali::DaliException e) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28935       };
28936     } catch (...) {
28937       {
28938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28939       };
28940     }
28941   }
28942
28943   jresult = result;
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28950   bool arg2 ;
28951
28952   arg1 = (Dali::RenderTask *)jarg1;
28953   arg2 = jarg2 ? true : false;
28954   {
28955     try {
28956       (arg1)->SetCullMode(arg2);
28957     } catch (std::out_of_range& e) {
28958       {
28959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28960       };
28961     } catch (std::exception& e) {
28962       {
28963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28964       };
28965     } catch (Dali::DaliException e) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28968       };
28969     } catch (...) {
28970       {
28971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28972       };
28973     }
28974   }
28975
28976 }
28977
28978
28979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28980   unsigned int jresult ;
28981   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28982   bool result;
28983
28984   arg1 = (Dali::RenderTask *)jarg1;
28985   {
28986     try {
28987       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28988     } catch (std::out_of_range& e) {
28989       {
28990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28991       };
28992     } catch (std::exception& e) {
28993       {
28994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28995       };
28996     } catch (Dali::DaliException e) {
28997       {
28998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28999       };
29000     } catch (...) {
29001       {
29002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29003       };
29004     }
29005   }
29006
29007   jresult = result;
29008   return jresult;
29009 }
29010
29011
29012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29014   unsigned int arg2 ;
29015
29016   arg1 = (Dali::RenderTask *)jarg1;
29017   arg2 = (unsigned int)jarg2;
29018   {
29019     try {
29020       (arg1)->SetRefreshRate(arg2);
29021     } catch (std::out_of_range& e) {
29022       {
29023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (std::exception& e) {
29026       {
29027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29028       };
29029     } catch (Dali::DaliException e) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29032       };
29033     } catch (...) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29036       };
29037     }
29038   }
29039
29040 }
29041
29042
29043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29044   unsigned int jresult ;
29045   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29046   unsigned int result;
29047
29048   arg1 = (Dali::RenderTask *)jarg1;
29049   {
29050     try {
29051       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29052     } catch (std::out_of_range& e) {
29053       {
29054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (std::exception& e) {
29057       {
29058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29059       };
29060     } catch (Dali::DaliException e) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29063       };
29064     } catch (...) {
29065       {
29066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29067       };
29068     }
29069   }
29070
29071   jresult = result;
29072   return jresult;
29073 }
29074
29075
29076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29077   unsigned int jresult ;
29078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29079   Dali::Vector3 *arg2 = 0 ;
29080   float *arg3 = 0 ;
29081   float *arg4 = 0 ;
29082   bool result;
29083
29084   arg1 = (Dali::RenderTask *)jarg1;
29085   arg2 = (Dali::Vector3 *)jarg2;
29086   if (!arg2) {
29087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29088     return 0;
29089   }
29090   arg3 = (float *)jarg3;
29091   arg4 = (float *)jarg4;
29092   {
29093     try {
29094       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29095     } catch (std::out_of_range& e) {
29096       {
29097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29098       };
29099     } catch (std::exception& e) {
29100       {
29101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29102       };
29103     } catch (Dali::DaliException e) {
29104       {
29105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29106       };
29107     } catch (...) {
29108       {
29109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29110       };
29111     }
29112   }
29113
29114   jresult = result;
29115   return jresult;
29116 }
29117
29118
29119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29120   unsigned int jresult ;
29121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29122   Dali::Actor arg2 ;
29123   float arg3 ;
29124   float arg4 ;
29125   float *arg5 = 0 ;
29126   float *arg6 = 0 ;
29127   Dali::Actor *argp2 ;
29128   bool result;
29129
29130   arg1 = (Dali::RenderTask *)jarg1;
29131   argp2 = (Dali::Actor *)jarg2;
29132   if (!argp2) {
29133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29134     return 0;
29135   }
29136   arg2 = *argp2;
29137   arg3 = (float)jarg3;
29138   arg4 = (float)jarg4;
29139   arg5 = (float *)jarg5;
29140   arg6 = (float *)jarg6;
29141   {
29142     try {
29143       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29144     } catch (std::out_of_range& e) {
29145       {
29146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29147       };
29148     } catch (std::exception& e) {
29149       {
29150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29151       };
29152     } catch (Dali::DaliException e) {
29153       {
29154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29155       };
29156     } catch (...) {
29157       {
29158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29159       };
29160     }
29161   }
29162
29163   jresult = result;
29164   return jresult;
29165 }
29166
29167
29168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29169   void * jresult ;
29170   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29171   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29172
29173   arg1 = (Dali::RenderTask *)jarg1;
29174   {
29175     try {
29176       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29177     } catch (std::out_of_range& e) {
29178       {
29179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29180       };
29181     } catch (std::exception& e) {
29182       {
29183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29184       };
29185     } catch (Dali::DaliException e) {
29186       {
29187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29188       };
29189     } catch (...) {
29190       {
29191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29192       };
29193     }
29194   }
29195
29196   jresult = (void *)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29202   void * jresult ;
29203   int arg1 ;
29204   Dali::TouchPoint::State arg2 ;
29205   float arg3 ;
29206   float arg4 ;
29207   Dali::TouchPoint *result = 0 ;
29208
29209   arg1 = (int)jarg1;
29210   arg2 = (Dali::TouchPoint::State)jarg2;
29211   arg3 = (float)jarg3;
29212   arg4 = (float)jarg4;
29213   {
29214     try {
29215       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29216     } catch (std::out_of_range& e) {
29217       {
29218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29219       };
29220     } catch (std::exception& e) {
29221       {
29222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29223       };
29224     } catch (Dali::DaliException e) {
29225       {
29226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29227       };
29228     } catch (...) {
29229       {
29230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29231       };
29232     }
29233   }
29234
29235   jresult = (void *)result;
29236   return jresult;
29237 }
29238
29239
29240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29241   void * jresult ;
29242   int arg1 ;
29243   Dali::TouchPoint::State arg2 ;
29244   float arg3 ;
29245   float arg4 ;
29246   float arg5 ;
29247   float arg6 ;
29248   Dali::TouchPoint *result = 0 ;
29249
29250   arg1 = (int)jarg1;
29251   arg2 = (Dali::TouchPoint::State)jarg2;
29252   arg3 = (float)jarg3;
29253   arg4 = (float)jarg4;
29254   arg5 = (float)jarg5;
29255   arg6 = (float)jarg6;
29256   {
29257     try {
29258       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29259     } catch (std::out_of_range& e) {
29260       {
29261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (std::exception& e) {
29264       {
29265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29266       };
29267     } catch (Dali::DaliException e) {
29268       {
29269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29270       };
29271     } catch (...) {
29272       {
29273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29274       };
29275     }
29276   }
29277
29278   jresult = (void *)result;
29279   return jresult;
29280 }
29281
29282
29283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29284   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29285
29286   arg1 = (Dali::TouchPoint *)jarg1;
29287   {
29288     try {
29289       delete arg1;
29290     } catch (std::out_of_range& e) {
29291       {
29292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29293       };
29294     } catch (std::exception& e) {
29295       {
29296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (Dali::DaliException e) {
29299       {
29300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29301       };
29302     } catch (...) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29305       };
29306     }
29307   }
29308
29309 }
29310
29311
29312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29313   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29314   int arg2 ;
29315
29316   arg1 = (Dali::TouchPoint *)jarg1;
29317   arg2 = (int)jarg2;
29318   if (arg1) (arg1)->deviceId = arg2;
29319 }
29320
29321
29322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29323   int jresult ;
29324   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29325   int result;
29326
29327   arg1 = (Dali::TouchPoint *)jarg1;
29328   result = (int) ((arg1)->deviceId);
29329   jresult = result;
29330   return jresult;
29331 }
29332
29333
29334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29335   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29336   Dali::TouchPoint::State arg2 ;
29337
29338   arg1 = (Dali::TouchPoint *)jarg1;
29339   arg2 = (Dali::TouchPoint::State)jarg2;
29340   if (arg1) (arg1)->state = arg2;
29341 }
29342
29343
29344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29345   int jresult ;
29346   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29347   Dali::TouchPoint::State result;
29348
29349   arg1 = (Dali::TouchPoint *)jarg1;
29350   result = (Dali::TouchPoint::State) ((arg1)->state);
29351   jresult = (int)result;
29352   return jresult;
29353 }
29354
29355
29356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29358   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29359
29360   arg1 = (Dali::TouchPoint *)jarg1;
29361   arg2 = (Dali::Actor *)jarg2;
29362   if (arg1) (arg1)->hitActor = *arg2;
29363 }
29364
29365
29366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29367   void * jresult ;
29368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29369   Dali::Actor *result = 0 ;
29370
29371   arg1 = (Dali::TouchPoint *)jarg1;
29372   result = (Dali::Actor *)& ((arg1)->hitActor);
29373   jresult = (void *)result;
29374   return jresult;
29375 }
29376
29377
29378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29380   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29381
29382   arg1 = (Dali::TouchPoint *)jarg1;
29383   arg2 = (Dali::Vector2 *)jarg2;
29384   if (arg1) (arg1)->local = *arg2;
29385 }
29386
29387
29388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29389   void * jresult ;
29390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29391   Dali::Vector2 *result = 0 ;
29392
29393   arg1 = (Dali::TouchPoint *)jarg1;
29394   result = (Dali::Vector2 *)& ((arg1)->local);
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29401   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29402   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29403
29404   arg1 = (Dali::TouchPoint *)jarg1;
29405   arg2 = (Dali::Vector2 *)jarg2;
29406   if (arg1) (arg1)->screen = *arg2;
29407 }
29408
29409
29410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29411   void * jresult ;
29412   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29413   Dali::Vector2 *result = 0 ;
29414
29415   arg1 = (Dali::TouchPoint *)jarg1;
29416   result = (Dali::Vector2 *)& ((arg1)->screen);
29417   jresult = (void *)result;
29418   return jresult;
29419 }
29420
29421
29422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29423   void * jresult ;
29424   Dali::TouchEvent *result = 0 ;
29425
29426   {
29427     try {
29428       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29429     } catch (std::out_of_range& e) {
29430       {
29431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29432       };
29433     } catch (std::exception& e) {
29434       {
29435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29436       };
29437     } catch (Dali::DaliException e) {
29438       {
29439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29440       };
29441     } catch (...) {
29442       {
29443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29444       };
29445     }
29446   }
29447
29448   jresult = (void *)result;
29449   return jresult;
29450 }
29451
29452
29453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29454   void * jresult ;
29455   Dali::TouchEvent *arg1 = 0 ;
29456   Dali::TouchEvent *result = 0 ;
29457
29458   arg1 = (Dali::TouchEvent *)jarg1;
29459   if (!arg1) {
29460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29461     return 0;
29462   }
29463   {
29464     try {
29465       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29466     } catch (std::out_of_range& e) {
29467       {
29468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (std::exception& e) {
29471       {
29472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (Dali::DaliException e) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29477       };
29478     } catch (...) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29481       };
29482     }
29483   }
29484
29485   jresult = (void *)result;
29486   return jresult;
29487 }
29488
29489
29490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29491   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29492
29493   arg1 = (Dali::TouchEvent *)jarg1;
29494   {
29495     try {
29496       delete arg1;
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29504       };
29505     } catch (Dali::DaliException e) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29508       };
29509     } catch (...) {
29510       {
29511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29512       };
29513     }
29514   }
29515
29516 }
29517
29518
29519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29520   void * jresult ;
29521   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29522   Dali::TouchEvent *arg2 = 0 ;
29523   Dali::TouchEvent *result = 0 ;
29524
29525   arg1 = (Dali::TouchEvent *)jarg1;
29526   arg2 = (Dali::TouchEvent *)jarg2;
29527   if (!arg2) {
29528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29529     return 0;
29530   }
29531   {
29532     try {
29533       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29534     } catch (std::out_of_range& e) {
29535       {
29536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (std::exception& e) {
29539       {
29540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (Dali::DaliException e) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29545       };
29546     } catch (...) {
29547       {
29548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29549       };
29550     }
29551   }
29552
29553   jresult = (void *)result;
29554   return jresult;
29555 }
29556
29557
29558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29559   unsigned long jresult ;
29560   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29561   unsigned long result;
29562
29563   arg1 = (Dali::TouchEvent *)jarg1;
29564   {
29565     try {
29566       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
29567     } catch (std::out_of_range& e) {
29568       {
29569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29570       };
29571     } catch (std::exception& e) {
29572       {
29573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29574       };
29575     } catch (Dali::DaliException e) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29578       };
29579     } catch (...) {
29580       {
29581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29582       };
29583     }
29584   }
29585
29586   jresult = (unsigned long)result;
29587   return jresult;
29588 }
29589
29590
29591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29592   unsigned long jresult ;
29593   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29594   std::size_t result;
29595
29596   arg1 = (Dali::TouchEvent *)jarg1;
29597   {
29598     try {
29599       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
29600     } catch (std::out_of_range& e) {
29601       {
29602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29603       };
29604     } catch (std::exception& e) {
29605       {
29606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (Dali::DaliException e) {
29609       {
29610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29611       };
29612     } catch (...) {
29613       {
29614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29615       };
29616     }
29617   }
29618
29619   jresult = (unsigned long)result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29625   int jresult ;
29626   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29627   std::size_t arg2 ;
29628   int32_t result;
29629
29630   arg1 = (Dali::TouchEvent *)jarg1;
29631   arg2 = (std::size_t)jarg2;
29632   {
29633     try {
29634       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29635     } catch (std::out_of_range& e) {
29636       {
29637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29638       };
29639     } catch (std::exception& e) {
29640       {
29641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29642       };
29643     } catch (Dali::DaliException e) {
29644       {
29645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29646       };
29647     } catch (...) {
29648       {
29649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29650       };
29651     }
29652   }
29653
29654   jresult = result;
29655   return jresult;
29656 }
29657
29658
29659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29660   int jresult ;
29661   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29662   std::size_t arg2 ;
29663   Dali::PointState::Type result;
29664
29665   arg1 = (Dali::TouchEvent *)jarg1;
29666   arg2 = (std::size_t)jarg2;
29667   {
29668     try {
29669       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29670     } catch (std::out_of_range& e) {
29671       {
29672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29673       };
29674     } catch (std::exception& e) {
29675       {
29676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29677       };
29678     } catch (Dali::DaliException e) {
29679       {
29680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29681       };
29682     } catch (...) {
29683       {
29684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29685       };
29686     }
29687   }
29688
29689   jresult = (int)result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29695   void * jresult ;
29696   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29697   std::size_t arg2 ;
29698   Dali::Actor result;
29699
29700   arg1 = (Dali::TouchEvent *)jarg1;
29701   arg2 = (std::size_t)jarg2;
29702   {
29703     try {
29704       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29705     } catch (std::out_of_range& e) {
29706       {
29707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (std::exception& e) {
29710       {
29711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29712       };
29713     } catch (Dali::DaliException e) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29716       };
29717     } catch (...) {
29718       {
29719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29720       };
29721     }
29722   }
29723
29724   jresult = new Dali::Actor((const Dali::Actor &)result);
29725   return jresult;
29726 }
29727
29728
29729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29730   void * jresult ;
29731   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29732   std::size_t arg2 ;
29733   Dali::Vector2 *result = 0 ;
29734
29735   arg1 = (Dali::TouchEvent *)jarg1;
29736   arg2 = (std::size_t)jarg2;
29737   {
29738     try {
29739       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29740     } catch (std::out_of_range& e) {
29741       {
29742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29743       };
29744     } catch (std::exception& e) {
29745       {
29746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29747       };
29748     } catch (Dali::DaliException e) {
29749       {
29750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29751       };
29752     } catch (...) {
29753       {
29754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29755       };
29756     }
29757   }
29758
29759   jresult = (void *)result;
29760   return jresult;
29761 }
29762
29763
29764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29765   void * jresult ;
29766   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29767   std::size_t arg2 ;
29768   Dali::Vector2 *result = 0 ;
29769
29770   arg1 = (Dali::TouchEvent *)jarg1;
29771   arg2 = (std::size_t)jarg2;
29772   {
29773     try {
29774       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29775     } catch (std::out_of_range& e) {
29776       {
29777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29778       };
29779     } catch (std::exception& e) {
29780       {
29781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29782       };
29783     } catch (Dali::DaliException e) {
29784       {
29785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29786       };
29787     } catch (...) {
29788       {
29789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29790       };
29791     }
29792   }
29793
29794   jresult = (void *)result;
29795   return jresult;
29796 }
29797
29798
29799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29800   float jresult ;
29801   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29802   std::size_t arg2 ;
29803   float result;
29804
29805   arg1 = (Dali::TouchEvent *)jarg1;
29806   arg2 = (std::size_t)jarg2;
29807   {
29808     try {
29809       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29810     } catch (std::out_of_range& e) {
29811       {
29812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29813       };
29814     } catch (std::exception& e) {
29815       {
29816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29817       };
29818     } catch (Dali::DaliException e) {
29819       {
29820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29821       };
29822     } catch (...) {
29823       {
29824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29825       };
29826     }
29827   }
29828
29829   jresult = result;
29830   return jresult;
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29835   void * jresult ;
29836   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29837   std::size_t arg2 ;
29838   Dali::Vector2 *result = 0 ;
29839
29840   arg1 = (Dali::TouchEvent *)jarg1;
29841   arg2 = (std::size_t)jarg2;
29842   {
29843     try {
29844       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29845     } catch (std::out_of_range& e) {
29846       {
29847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29848       };
29849     } catch (std::exception& e) {
29850       {
29851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (Dali::DaliException e) {
29854       {
29855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29856       };
29857     } catch (...) {
29858       {
29859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29860       };
29861     }
29862   }
29863
29864   jresult = (void *)result;
29865   return jresult;
29866 }
29867
29868
29869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29870   float jresult ;
29871   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29872   std::size_t arg2 ;
29873   float result;
29874
29875   arg1 = (Dali::TouchEvent *)jarg1;
29876   arg2 = (std::size_t)jarg2;
29877   {
29878     try {
29879       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29880     } catch (std::out_of_range& e) {
29881       {
29882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29883       };
29884     } catch (std::exception& e) {
29885       {
29886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29887       };
29888     } catch (Dali::DaliException e) {
29889       {
29890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29891       };
29892     } catch (...) {
29893       {
29894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29895       };
29896     }
29897   }
29898
29899   jresult = result;
29900   return jresult;
29901 }
29902
29903
29904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29905   void * jresult ;
29906   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29907   std::size_t arg2 ;
29908   Dali::Degree result;
29909
29910   arg1 = (Dali::TouchEvent *)jarg1;
29911   arg2 = (std::size_t)jarg2;
29912   {
29913     try {
29914       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29915     } catch (std::out_of_range& e) {
29916       {
29917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29918       };
29919     } catch (std::exception& e) {
29920       {
29921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29922       };
29923     } catch (Dali::DaliException e) {
29924       {
29925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29926       };
29927     } catch (...) {
29928       {
29929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29930       };
29931     }
29932   }
29933
29934   jresult = new Dali::Degree((const Dali::Degree &)result);
29935   return jresult;
29936 }
29937
29938
29939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29940   int jresult ;
29941   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29942   std::size_t arg2 ;
29943   Dali::MouseButton::Type result;
29944
29945   arg1 = (Dali::TouchEvent *)jarg1;
29946   arg2 = (std::size_t)jarg2;
29947   {
29948     try {
29949       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29950     } catch (std::out_of_range& e) {
29951       {
29952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (std::exception& e) {
29955       {
29956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29957       };
29958     } catch (Dali::DaliException e) {
29959       {
29960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29961       };
29962     } catch (...) {
29963       {
29964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29965       };
29966     }
29967   }
29968
29969   jresult = static_cast< int >(result);
29970   return jresult;
29971 }
29972
29973
29974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29975   void * jresult ;
29976   Dali::GestureDetector *result = 0 ;
29977
29978   {
29979     try {
29980       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29981     } catch (std::out_of_range& e) {
29982       {
29983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (std::exception& e) {
29986       {
29987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29988       };
29989     } catch (Dali::DaliException e) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29992       };
29993     } catch (...) {
29994       {
29995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29996       };
29997     }
29998   }
29999
30000   jresult = (void *)result;
30001   return jresult;
30002 }
30003
30004
30005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30006   void * jresult ;
30007   Dali::BaseHandle arg1 ;
30008   Dali::BaseHandle *argp1 ;
30009   Dali::GestureDetector result;
30010
30011   argp1 = (Dali::BaseHandle *)jarg1;
30012   if (!argp1) {
30013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30014     return 0;
30015   }
30016   arg1 = *argp1;
30017   {
30018     try {
30019       result = Dali::GestureDetector::DownCast(arg1);
30020     } catch (std::out_of_range& e) {
30021       {
30022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30023       };
30024     } catch (std::exception& e) {
30025       {
30026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30027       };
30028     } catch (Dali::DaliException e) {
30029       {
30030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30031       };
30032     } catch (...) {
30033       {
30034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30035       };
30036     }
30037   }
30038
30039   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30040   return jresult;
30041 }
30042
30043
30044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30045   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30046
30047   arg1 = (Dali::GestureDetector *)jarg1;
30048   {
30049     try {
30050       delete arg1;
30051     } catch (std::out_of_range& e) {
30052       {
30053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30054       };
30055     } catch (std::exception& e) {
30056       {
30057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30058       };
30059     } catch (Dali::DaliException e) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30062       };
30063     } catch (...) {
30064       {
30065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30066       };
30067     }
30068   }
30069
30070 }
30071
30072
30073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30074   void * jresult ;
30075   Dali::GestureDetector *arg1 = 0 ;
30076   Dali::GestureDetector *result = 0 ;
30077
30078   arg1 = (Dali::GestureDetector *)jarg1;
30079   if (!arg1) {
30080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30081     return 0;
30082   }
30083   {
30084     try {
30085       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30086     } catch (std::out_of_range& e) {
30087       {
30088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (std::exception& e) {
30091       {
30092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30093       };
30094     } catch (Dali::DaliException e) {
30095       {
30096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30097       };
30098     } catch (...) {
30099       {
30100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30101       };
30102     }
30103   }
30104
30105   jresult = (void *)result;
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30111   void * jresult ;
30112   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30113   Dali::GestureDetector *arg2 = 0 ;
30114   Dali::GestureDetector *result = 0 ;
30115
30116   arg1 = (Dali::GestureDetector *)jarg1;
30117   arg2 = (Dali::GestureDetector *)jarg2;
30118   if (!arg2) {
30119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30120     return 0;
30121   }
30122   {
30123     try {
30124       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30125     } catch (std::out_of_range& e) {
30126       {
30127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30128       };
30129     } catch (std::exception& e) {
30130       {
30131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30132       };
30133     } catch (Dali::DaliException e) {
30134       {
30135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30136       };
30137     } catch (...) {
30138       {
30139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30140       };
30141     }
30142   }
30143
30144   jresult = (void *)result;
30145   return jresult;
30146 }
30147
30148
30149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30150   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30151   Dali::Actor arg2 ;
30152   Dali::Actor *argp2 ;
30153
30154   arg1 = (Dali::GestureDetector *)jarg1;
30155   argp2 = (Dali::Actor *)jarg2;
30156   if (!argp2) {
30157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30158     return ;
30159   }
30160   arg2 = *argp2;
30161   {
30162     try {
30163       (arg1)->Attach(arg2);
30164     } catch (std::out_of_range& e) {
30165       {
30166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30167       };
30168     } catch (std::exception& e) {
30169       {
30170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30171       };
30172     } catch (Dali::DaliException e) {
30173       {
30174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30175       };
30176     } catch (...) {
30177       {
30178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30179       };
30180     }
30181   }
30182
30183 }
30184
30185
30186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30187   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30188   Dali::Actor arg2 ;
30189   Dali::Actor *argp2 ;
30190
30191   arg1 = (Dali::GestureDetector *)jarg1;
30192   argp2 = (Dali::Actor *)jarg2;
30193   if (!argp2) {
30194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30195     return ;
30196   }
30197   arg2 = *argp2;
30198   {
30199     try {
30200       (arg1)->Detach(arg2);
30201     } catch (std::out_of_range& e) {
30202       {
30203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30204       };
30205     } catch (std::exception& e) {
30206       {
30207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30208       };
30209     } catch (Dali::DaliException e) {
30210       {
30211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30212       };
30213     } catch (...) {
30214       {
30215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30216       };
30217     }
30218   }
30219
30220 }
30221
30222
30223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30224   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30225
30226   arg1 = (Dali::GestureDetector *)jarg1;
30227   {
30228     try {
30229       (arg1)->DetachAll();
30230     } catch (std::out_of_range& e) {
30231       {
30232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30233       };
30234     } catch (std::exception& e) {
30235       {
30236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30237       };
30238     } catch (Dali::DaliException e) {
30239       {
30240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30241       };
30242     } catch (...) {
30243       {
30244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30245       };
30246     }
30247   }
30248
30249 }
30250
30251
30252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30253   unsigned long jresult ;
30254   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30255   size_t result;
30256
30257   arg1 = (Dali::GestureDetector *)jarg1;
30258   {
30259     try {
30260       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30261     } catch (std::out_of_range& e) {
30262       {
30263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30264       };
30265     } catch (std::exception& e) {
30266       {
30267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30268       };
30269     } catch (Dali::DaliException e) {
30270       {
30271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30276       };
30277     }
30278   }
30279
30280   jresult = (unsigned long)result;
30281   return jresult;
30282 }
30283
30284
30285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30286   void * jresult ;
30287   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30288   size_t arg2 ;
30289   Dali::Actor result;
30290
30291   arg1 = (Dali::GestureDetector *)jarg1;
30292   arg2 = (size_t)jarg2;
30293   {
30294     try {
30295       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30296     } catch (std::out_of_range& e) {
30297       {
30298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (std::exception& e) {
30301       {
30302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30303       };
30304     } catch (Dali::DaliException e) {
30305       {
30306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30307       };
30308     } catch (...) {
30309       {
30310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30311       };
30312     }
30313   }
30314
30315   jresult = new Dali::Actor((const Dali::Actor &)result);
30316   return jresult;
30317 }
30318
30319
30320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30321   void * jresult ;
30322   Dali::Gesture *arg1 = 0 ;
30323   Dali::Gesture *result = 0 ;
30324
30325   arg1 = (Dali::Gesture *)jarg1;
30326   if (!arg1) {
30327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30328     return 0;
30329   }
30330   {
30331     try {
30332       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30333     } catch (std::out_of_range& e) {
30334       {
30335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30336       };
30337     } catch (std::exception& e) {
30338       {
30339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30340       };
30341     } catch (Dali::DaliException e) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30344       };
30345     } catch (...) {
30346       {
30347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30348       };
30349     }
30350   }
30351
30352   jresult = (void *)result;
30353   return jresult;
30354 }
30355
30356
30357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30358   void * jresult ;
30359   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30360   Dali::Gesture *arg2 = 0 ;
30361   Dali::Gesture *result = 0 ;
30362
30363   arg1 = (Dali::Gesture *)jarg1;
30364   arg2 = (Dali::Gesture *)jarg2;
30365   if (!arg2) {
30366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30367     return 0;
30368   }
30369   {
30370     try {
30371       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30372     } catch (std::out_of_range& e) {
30373       {
30374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30375       };
30376     } catch (std::exception& e) {
30377       {
30378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30379       };
30380     } catch (Dali::DaliException e) {
30381       {
30382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30383       };
30384     } catch (...) {
30385       {
30386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30387       };
30388     }
30389   }
30390
30391   jresult = (void *)result;
30392   return jresult;
30393 }
30394
30395
30396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30397   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30398
30399   arg1 = (Dali::Gesture *)jarg1;
30400   {
30401     try {
30402       delete arg1;
30403     } catch (std::out_of_range& e) {
30404       {
30405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30406       };
30407     } catch (std::exception& e) {
30408       {
30409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30410       };
30411     } catch (Dali::DaliException e) {
30412       {
30413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30414       };
30415     } catch (...) {
30416       {
30417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30418       };
30419     }
30420   }
30421
30422 }
30423
30424
30425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30426   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30427   Dali::Gesture::Type arg2 ;
30428
30429   arg1 = (Dali::Gesture *)jarg1;
30430   arg2 = (Dali::Gesture::Type)jarg2;
30431   if (arg1) (arg1)->type = arg2;
30432 }
30433
30434
30435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30436   int jresult ;
30437   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30438   Dali::Gesture::Type result;
30439
30440   arg1 = (Dali::Gesture *)jarg1;
30441   result = (Dali::Gesture::Type) ((arg1)->type);
30442   jresult = (int)result;
30443   return jresult;
30444 }
30445
30446
30447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30448   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30449   Dali::Gesture::State arg2 ;
30450
30451   arg1 = (Dali::Gesture *)jarg1;
30452   arg2 = (Dali::Gesture::State)jarg2;
30453   if (arg1) (arg1)->state = arg2;
30454 }
30455
30456
30457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30458   int jresult ;
30459   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30460   Dali::Gesture::State result;
30461
30462   arg1 = (Dali::Gesture *)jarg1;
30463   result = (Dali::Gesture::State) ((arg1)->state);
30464   jresult = (int)result;
30465   return jresult;
30466 }
30467
30468
30469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30470   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30471   unsigned int arg2 ;
30472
30473   arg1 = (Dali::Gesture *)jarg1;
30474   arg2 = (unsigned int)jarg2;
30475   if (arg1) (arg1)->time = arg2;
30476 }
30477
30478
30479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30480   unsigned int jresult ;
30481   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30482   unsigned int result;
30483
30484   arg1 = (Dali::Gesture *)jarg1;
30485   result = (unsigned int) ((arg1)->time);
30486   jresult = result;
30487   return jresult;
30488 }
30489
30490
30491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30492   void * jresult ;
30493   Dali::HoverEvent *result = 0 ;
30494
30495   {
30496     try {
30497       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30513       };
30514     }
30515   }
30516
30517   jresult = (void *)result;
30518   return jresult;
30519 }
30520
30521
30522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30523   void * jresult ;
30524   Dali::HoverEvent *arg1 = 0 ;
30525   Dali::HoverEvent *result = 0 ;
30526
30527   arg1 = (Dali::HoverEvent *)jarg1;
30528   if (!arg1) {
30529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30530     return 0;
30531   }
30532   {
30533     try {
30534       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30535     } catch (std::out_of_range& e) {
30536       {
30537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (std::exception& e) {
30540       {
30541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30542       };
30543     } catch (Dali::DaliException e) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30546       };
30547     } catch (...) {
30548       {
30549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30550       };
30551     }
30552   }
30553
30554   jresult = (void *)result;
30555   return jresult;
30556 }
30557
30558
30559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30560   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30561
30562   arg1 = (Dali::HoverEvent *)jarg1;
30563   {
30564     try {
30565       delete arg1;
30566     } catch (std::out_of_range& e) {
30567       {
30568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (std::exception& e) {
30571       {
30572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30573       };
30574     } catch (Dali::DaliException e) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30577       };
30578     } catch (...) {
30579       {
30580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30581       };
30582     }
30583   }
30584
30585 }
30586
30587
30588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30589   void * jresult ;
30590   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30591   Dali::HoverEvent *arg2 = 0 ;
30592   Dali::HoverEvent *result = 0 ;
30593
30594   arg1 = (Dali::HoverEvent *)jarg1;
30595   arg2 = (Dali::HoverEvent *)jarg2;
30596   if (!arg2) {
30597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30598     return 0;
30599   }
30600   {
30601     try {
30602       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30603     } catch (std::out_of_range& e) {
30604       {
30605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (std::exception& e) {
30608       {
30609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30610       };
30611     } catch (Dali::DaliException e) {
30612       {
30613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30614       };
30615     } catch (...) {
30616       {
30617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30618       };
30619     }
30620   }
30621
30622   jresult = (void *)result;
30623   return jresult;
30624 }
30625
30626
30627 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30628   unsigned long jresult ;
30629   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30630   unsigned long result;
30631
30632   arg1 = (Dali::HoverEvent *)jarg1;
30633   {
30634     try {
30635       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30636     } catch (std::out_of_range& e) {
30637       {
30638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30639       };
30640     } catch (std::exception& e) {
30641       {
30642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30643       };
30644     } catch (Dali::DaliException e) {
30645       {
30646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30647       };
30648     } catch (...) {
30649       {
30650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30651       };
30652     }
30653   }
30654
30655   jresult = (unsigned long)result;
30656   return jresult;
30657 }
30658
30659
30660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30661   unsigned long jresult ;
30662   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30663   std::size_t result;
30664
30665   arg1 = (Dali::HoverEvent *)jarg1;
30666   {
30667     try {
30668       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (Dali::DaliException e) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30680       };
30681     } catch (...) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30684       };
30685     }
30686   }
30687
30688   jresult = (unsigned long)result;
30689   return jresult;
30690 }
30691
30692
30693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30694   int jresult ;
30695   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30696   std::size_t arg2 ;
30697   int32_t result;
30698
30699   arg1 = (Dali::HoverEvent *)jarg1;
30700   arg2 = (std::size_t)jarg2;
30701   {
30702     try {
30703       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30704     } catch (std::out_of_range& e) {
30705       {
30706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30707       };
30708     } catch (std::exception& e) {
30709       {
30710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30711       };
30712     } catch (Dali::DaliException e) {
30713       {
30714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30715       };
30716     } catch (...) {
30717       {
30718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30719       };
30720     }
30721   }
30722
30723   jresult = result;
30724   return jresult;
30725 }
30726
30727
30728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30729   int jresult ;
30730   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30731   std::size_t arg2 ;
30732   Dali::PointState::Type result;
30733
30734   arg1 = (Dali::HoverEvent *)jarg1;
30735   arg2 = (std::size_t)jarg2;
30736   {
30737     try {
30738       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30739     } catch (std::out_of_range& e) {
30740       {
30741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30742       };
30743     } catch (std::exception& e) {
30744       {
30745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30746       };
30747     } catch (Dali::DaliException e) {
30748       {
30749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30750       };
30751     } catch (...) {
30752       {
30753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30754       };
30755     }
30756   }
30757
30758   jresult = (int)result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30764   void * jresult ;
30765   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30766   std::size_t arg2 ;
30767   Dali::Actor result;
30768
30769   arg1 = (Dali::HoverEvent *)jarg1;
30770   arg2 = (std::size_t)jarg2;
30771   {
30772     try {
30773       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30774     } catch (std::out_of_range& e) {
30775       {
30776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (std::exception& e) {
30779       {
30780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30781       };
30782     } catch (Dali::DaliException e) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30785       };
30786     } catch (...) {
30787       {
30788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30789       };
30790     }
30791   }
30792
30793   jresult = new Dali::Actor((const Dali::Actor &)result);
30794   return jresult;
30795 }
30796
30797
30798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30799   void * jresult ;
30800   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30801   std::size_t arg2 ;
30802   Dali::Vector2 *result = 0 ;
30803
30804   arg1 = (Dali::HoverEvent *)jarg1;
30805   arg2 = (std::size_t)jarg2;
30806   {
30807     try {
30808       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30809     } catch (std::out_of_range& e) {
30810       {
30811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30812       };
30813     } catch (std::exception& e) {
30814       {
30815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30816       };
30817     } catch (Dali::DaliException e) {
30818       {
30819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30820       };
30821     } catch (...) {
30822       {
30823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30824       };
30825     }
30826   }
30827
30828   jresult = (void *)result;
30829   return jresult;
30830 }
30831
30832
30833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30834   void * jresult ;
30835   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30836   std::size_t arg2 ;
30837   Dali::Vector2 *result = 0 ;
30838
30839   arg1 = (Dali::HoverEvent *)jarg1;
30840   arg2 = (std::size_t)jarg2;
30841   {
30842     try {
30843       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30844     } catch (std::out_of_range& e) {
30845       {
30846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30847       };
30848     } catch (std::exception& e) {
30849       {
30850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30851       };
30852     } catch (Dali::DaliException e) {
30853       {
30854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30855       };
30856     } catch (...) {
30857       {
30858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30859       };
30860     }
30861   }
30862
30863   jresult = (void *)result;
30864   return jresult;
30865 }
30866
30867
30868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30869   void * jresult ;
30870   Dali::KeyEvent *result = 0 ;
30871
30872   {
30873     try {
30874       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30875     } catch (std::out_of_range& e) {
30876       {
30877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30878       };
30879     } catch (std::exception& e) {
30880       {
30881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30882       };
30883     } catch (Dali::DaliException e) {
30884       {
30885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30886       };
30887     } catch (...) {
30888       {
30889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30890       };
30891     }
30892   }
30893
30894   jresult = (void *)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30900   void * jresult ;
30901   std::string *arg1 = 0 ;
30902   std::string *arg2 = 0 ;
30903   int arg3 ;
30904   int arg4 ;
30905   unsigned long arg5 ;
30906   Dali::KeyEvent::State *arg6 = 0 ;
30907   Dali::KeyEvent::State temp6 ;
30908   Dali::KeyEvent *result = 0 ;
30909
30910   if (!jarg1) {
30911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30912     return 0;
30913   }
30914   std::string arg1_str(jarg1);
30915   arg1 = &arg1_str;
30916   if (!jarg2) {
30917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30918     return 0;
30919   }
30920   std::string arg2_str(jarg2);
30921   arg2 = &arg2_str;
30922   arg3 = (int)jarg3;
30923   arg4 = (int)jarg4;
30924   arg5 = (unsigned long)jarg5;
30925   temp6 = (Dali::KeyEvent::State)jarg6;
30926   arg6 = &temp6;
30927   {
30928     try {
30929       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30930     } catch (std::out_of_range& e) {
30931       {
30932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (std::exception& e) {
30935       {
30936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (Dali::DaliException e) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30941       };
30942     } catch (...) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30945       };
30946     }
30947   }
30948
30949   jresult = (void *)result;
30950
30951   //argout typemap for const std::string&
30952
30953
30954   //argout typemap for const std::string&
30955
30956   return jresult;
30957 }
30958
30959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30960   void * jresult ;
30961   Dali::KeyEvent *arg1 = 0 ;
30962   Dali::KeyEvent *result = 0 ;
30963
30964   arg1 = (Dali::KeyEvent *)jarg1;
30965   if (!arg1) {
30966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30967     return 0;
30968   }
30969   {
30970     try {
30971       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30972     } catch (std::out_of_range& e) {
30973       {
30974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30975       };
30976     } catch (std::exception& e) {
30977       {
30978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (Dali::DaliException e) {
30981       {
30982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30987       };
30988     }
30989   }
30990
30991   jresult = (void *)result;
30992   return jresult;
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30997   void * jresult ;
30998   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30999   Dali::KeyEvent *arg2 = 0 ;
31000   Dali::KeyEvent *result = 0 ;
31001
31002   arg1 = (Dali::KeyEvent *)jarg1;
31003   arg2 = (Dali::KeyEvent *)jarg2;
31004   if (!arg2) {
31005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31006     return 0;
31007   }
31008   {
31009     try {
31010       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31011     } catch (std::out_of_range& e) {
31012       {
31013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31014       };
31015     } catch (std::exception& e) {
31016       {
31017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31018       };
31019     } catch (Dali::DaliException e) {
31020       {
31021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31022       };
31023     } catch (...) {
31024       {
31025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31026       };
31027     }
31028   }
31029
31030   jresult = (void *)result;
31031   return jresult;
31032 }
31033
31034
31035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31036   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31037
31038   arg1 = (Dali::KeyEvent *)jarg1;
31039   {
31040     try {
31041       delete arg1;
31042     } catch (std::out_of_range& e) {
31043       {
31044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31045       };
31046     } catch (std::exception& e) {
31047       {
31048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31049       };
31050     } catch (Dali::DaliException e) {
31051       {
31052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31053       };
31054     } catch (...) {
31055       {
31056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31057       };
31058     }
31059   }
31060
31061 }
31062
31063
31064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31065   unsigned int jresult ;
31066   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31067   bool result;
31068
31069   arg1 = (Dali::KeyEvent *)jarg1;
31070   {
31071     try {
31072       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31098   unsigned int jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   bool result;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   {
31104     try {
31105       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31106     } catch (std::out_of_range& e) {
31107       {
31108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31109       };
31110     } catch (std::exception& e) {
31111       {
31112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (Dali::DaliException e) {
31115       {
31116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31117       };
31118     } catch (...) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31121       };
31122     }
31123   }
31124
31125   jresult = result;
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31131   unsigned int jresult ;
31132   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31133   bool result;
31134
31135   arg1 = (Dali::KeyEvent *)jarg1;
31136   {
31137     try {
31138       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31146       };
31147     } catch (Dali::DaliException e) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31150       };
31151     } catch (...) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31154       };
31155     }
31156   }
31157
31158   jresult = result;
31159   return jresult;
31160 }
31161
31162
31163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31164   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31165   std::string *arg2 = 0 ;
31166
31167   arg1 = (Dali::KeyEvent *)jarg1;
31168   if (!jarg2) {
31169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31170     return ;
31171   }
31172   std::string arg2_str(jarg2);
31173   arg2 = &arg2_str;
31174   if (arg1) (arg1)->keyPressedName = *arg2;
31175
31176   //argout typemap for const std::string&
31177
31178 }
31179
31180
31181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31182   char * jresult ;
31183
31184   if( jarg1 == NULL )
31185   {
31186     jresult = SWIG_csharp_string_callback( "" );
31187   }
31188   else
31189   {
31190     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31191     std::string *result = 0;
31192
31193     arg1 = ( Dali::KeyEvent * )jarg1;
31194     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31195     jresult = SWIG_csharp_string_callback( result->c_str() );
31196   }
31197
31198   return jresult;
31199 }
31200
31201
31202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31203   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31204   std::string *arg2 = 0 ;
31205
31206   arg1 = (Dali::KeyEvent *)jarg1;
31207   if (!jarg2) {
31208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31209     return ;
31210   }
31211   std::string arg2_str(jarg2);
31212   arg2 = &arg2_str;
31213   if (arg1) (arg1)->keyPressed = *arg2;
31214
31215   //argout typemap for const std::string&
31216
31217 }
31218
31219
31220 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31221   char * jresult ;
31222   if( NULL == jarg1 )
31223   {
31224     jresult = SWIG_csharp_string_callback( "" );
31225   }
31226   else
31227   {
31228     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31229     std::string *result = 0;
31230
31231     arg1 = ( Dali::KeyEvent * )jarg1;
31232     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31233     jresult = SWIG_csharp_string_callback( result->c_str() );
31234   }
31235   return jresult;
31236 }
31237
31238
31239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31240   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31241   int arg2 ;
31242
31243   arg1 = (Dali::KeyEvent *)jarg1;
31244   arg2 = (int)jarg2;
31245   if (arg1) (arg1)->keyCode = arg2;
31246 }
31247
31248
31249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31250   int jresult ;
31251   if( NULL == jarg1 )
31252   {
31253     jresult = -1;
31254   }
31255   else
31256   {
31257     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31258     int result;
31259
31260     arg1 = ( Dali::KeyEvent * )jarg1;
31261     result = (int)( ( arg1 )->keyCode );
31262     jresult = result;
31263   }
31264   return jresult;
31265 }
31266
31267
31268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31269   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31270   int arg2 ;
31271
31272   arg1 = (Dali::KeyEvent *)jarg1;
31273   arg2 = (int)jarg2;
31274   if (arg1) (arg1)->keyModifier = arg2;
31275 }
31276
31277
31278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31279   int jresult ;
31280   if( jarg1 == NULL )
31281   {
31282     jresult = -1;
31283   }
31284   else
31285   {
31286     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31287     int result;
31288
31289     arg1 = ( Dali::KeyEvent * )jarg1;
31290     result = (int)( ( arg1 )->keyModifier );
31291     jresult = result;
31292   }
31293   return jresult;
31294 }
31295
31296
31297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31298   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31299   unsigned long arg2 ;
31300
31301   arg1 = (Dali::KeyEvent *)jarg1;
31302   arg2 = (unsigned long)jarg2;
31303   if (arg1) (arg1)->time = arg2;
31304 }
31305
31306
31307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31308   unsigned long jresult ;
31309   if( jarg1 == NULL )
31310   {
31311     jresult = 0;
31312   }
31313   else
31314   {
31315     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31316     unsigned long result;
31317
31318     arg1 = ( Dali::KeyEvent * )jarg1;
31319     result = (unsigned long)( ( arg1 )->time );
31320     jresult = (unsigned long)result;
31321   }
31322   return jresult;
31323 }
31324
31325
31326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31327   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31328   Dali::KeyEvent::State arg2 ;
31329
31330   arg1 = (Dali::KeyEvent *)jarg1;
31331   arg2 = (Dali::KeyEvent::State)jarg2;
31332   if (arg1) (arg1)->state = arg2;
31333 }
31334
31335
31336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31337   int jresult ;
31338   if( jarg1 == NULL )
31339   {
31340     jresult = -1;
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     Dali::KeyEvent::State result;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31349     jresult = (int)result;
31350   }
31351   return jresult;
31352 }
31353
31354 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31355   char * jresult ;
31356   std::string result;
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31358
31359   arg1 = (Dali::KeyEvent *)jarg1;
31360   if (!arg1) {
31361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31362     return 0;
31363   }
31364   {
31365     try {
31366       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31367     } catch (std::out_of_range& e) {
31368       {
31369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31370       };
31371     } catch (std::exception& e) {
31372       {
31373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31374       };
31375     } catch (Dali::DaliException e) {
31376       {
31377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31378       };
31379     } catch (...) {
31380       {
31381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31382       };
31383     }
31384
31385   }
31386
31387   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31388   return jresult;
31389 }
31390
31391
31392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31393   void * jresult ;
31394   Dali::LongPressGestureDetector *result = 0 ;
31395
31396   {
31397     try {
31398       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31399     } catch (std::out_of_range& e) {
31400       {
31401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31402       };
31403     } catch (std::exception& e) {
31404       {
31405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31406       };
31407     } catch (Dali::DaliException e) {
31408       {
31409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31410       };
31411     } catch (...) {
31412       {
31413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31414       };
31415     }
31416   }
31417
31418   jresult = (void *)result;
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31424   void * jresult ;
31425   Dali::LongPressGestureDetector result;
31426
31427   {
31428     try {
31429       result = Dali::LongPressGestureDetector::New();
31430     } catch (std::out_of_range& e) {
31431       {
31432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31433       };
31434     } catch (std::exception& e) {
31435       {
31436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31437       };
31438     } catch (Dali::DaliException e) {
31439       {
31440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31441       };
31442     } catch (...) {
31443       {
31444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31445       };
31446     }
31447   }
31448
31449   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31450   return jresult;
31451 }
31452
31453
31454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31455   void * jresult ;
31456   unsigned int arg1 ;
31457   Dali::LongPressGestureDetector result;
31458
31459   arg1 = (unsigned int)jarg1;
31460   {
31461     try {
31462       result = Dali::LongPressGestureDetector::New(arg1);
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31488   void * jresult ;
31489   unsigned int arg1 ;
31490   unsigned int arg2 ;
31491   Dali::LongPressGestureDetector result;
31492
31493   arg1 = (unsigned int)jarg1;
31494   arg2 = (unsigned int)jarg2;
31495   {
31496     try {
31497       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31498     } catch (std::out_of_range& e) {
31499       {
31500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (std::exception& e) {
31503       {
31504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31505       };
31506     } catch (Dali::DaliException e) {
31507       {
31508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31509       };
31510     } catch (...) {
31511       {
31512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31513       };
31514     }
31515   }
31516
31517   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31518   return jresult;
31519 }
31520
31521
31522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31523   void * jresult ;
31524   Dali::BaseHandle arg1 ;
31525   Dali::BaseHandle *argp1 ;
31526   Dali::LongPressGestureDetector result;
31527
31528   argp1 = (Dali::BaseHandle *)jarg1;
31529   if (!argp1) {
31530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31531     return 0;
31532   }
31533   arg1 = *argp1;
31534   {
31535     try {
31536       result = Dali::LongPressGestureDetector::DownCast(arg1);
31537     } catch (std::out_of_range& e) {
31538       {
31539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31540       };
31541     } catch (std::exception& e) {
31542       {
31543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31544       };
31545     } catch (Dali::DaliException e) {
31546       {
31547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31548       };
31549     } catch (...) {
31550       {
31551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31552       };
31553     }
31554   }
31555
31556   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31557   return jresult;
31558 }
31559
31560
31561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31562   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31563
31564   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31565   {
31566     try {
31567       delete arg1;
31568     } catch (std::out_of_range& e) {
31569       {
31570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31571       };
31572     } catch (std::exception& e) {
31573       {
31574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31575       };
31576     } catch (Dali::DaliException e) {
31577       {
31578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31579       };
31580     } catch (...) {
31581       {
31582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31583       };
31584     }
31585   }
31586
31587 }
31588
31589
31590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31591   void * jresult ;
31592   Dali::LongPressGestureDetector *arg1 = 0 ;
31593   Dali::LongPressGestureDetector *result = 0 ;
31594
31595   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31596   if (!arg1) {
31597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31598     return 0;
31599   }
31600   {
31601     try {
31602       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31603     } catch (std::out_of_range& e) {
31604       {
31605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31606       };
31607     } catch (std::exception& e) {
31608       {
31609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31610       };
31611     } catch (Dali::DaliException e) {
31612       {
31613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31614       };
31615     } catch (...) {
31616       {
31617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31618       };
31619     }
31620   }
31621
31622   jresult = (void *)result;
31623   return jresult;
31624 }
31625
31626
31627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31628   void * jresult ;
31629   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31630   Dali::LongPressGestureDetector *arg2 = 0 ;
31631   Dali::LongPressGestureDetector *result = 0 ;
31632
31633   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31634   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31635   if (!arg2) {
31636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31637     return 0;
31638   }
31639   {
31640     try {
31641       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
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 = (void *)result;
31662   return jresult;
31663 }
31664
31665
31666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31667   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31668   unsigned int arg2 ;
31669
31670   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31671   arg2 = (unsigned int)jarg2;
31672   {
31673     try {
31674       (arg1)->SetTouchesRequired(arg2);
31675     } catch (std::out_of_range& e) {
31676       {
31677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31678       };
31679     } catch (std::exception& e) {
31680       {
31681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31682       };
31683     } catch (Dali::DaliException e) {
31684       {
31685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31690       };
31691     }
31692   }
31693
31694 }
31695
31696
31697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31698   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31699   unsigned int arg2 ;
31700   unsigned int arg3 ;
31701
31702   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31703   arg2 = (unsigned int)jarg2;
31704   arg3 = (unsigned int)jarg3;
31705   {
31706     try {
31707       (arg1)->SetTouchesRequired(arg2,arg3);
31708     } catch (std::out_of_range& e) {
31709       {
31710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31711       };
31712     } catch (std::exception& e) {
31713       {
31714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31715       };
31716     } catch (Dali::DaliException e) {
31717       {
31718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31719       };
31720     } catch (...) {
31721       {
31722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31723       };
31724     }
31725   }
31726
31727 }
31728
31729
31730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31731   unsigned int jresult ;
31732   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31733   unsigned int result;
31734
31735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31736   {
31737     try {
31738       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31754       };
31755     }
31756   }
31757
31758   jresult = result;
31759   return jresult;
31760 }
31761
31762
31763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31764   unsigned int jresult ;
31765   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31766   unsigned int result;
31767
31768   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31769   {
31770     try {
31771       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31787       };
31788     }
31789   }
31790
31791   jresult = result;
31792   return jresult;
31793 }
31794
31795
31796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31797   void * jresult ;
31798   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31799   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31800
31801   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31802   {
31803     try {
31804       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31805     } catch (std::out_of_range& e) {
31806       {
31807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (std::exception& e) {
31810       {
31811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31812       };
31813     } catch (Dali::DaliException e) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31816       };
31817     } catch (...) {
31818       {
31819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31820       };
31821     }
31822   }
31823
31824   jresult = (void *)result;
31825   return jresult;
31826 }
31827
31828
31829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31830   void * jresult ;
31831   Dali::Gesture::State arg1 ;
31832   Dali::LongPressGesture *result = 0 ;
31833
31834   arg1 = (Dali::Gesture::State)jarg1;
31835   {
31836     try {
31837       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31838     } catch (std::out_of_range& e) {
31839       {
31840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31841       };
31842     } catch (std::exception& e) {
31843       {
31844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (Dali::DaliException e) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856
31857   jresult = (void *)result;
31858   return jresult;
31859 }
31860
31861
31862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31863   void * jresult ;
31864   Dali::LongPressGesture *arg1 = 0 ;
31865   Dali::LongPressGesture *result = 0 ;
31866
31867   arg1 = (Dali::LongPressGesture *)jarg1;
31868   if (!arg1) {
31869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31870     return 0;
31871   }
31872   {
31873     try {
31874       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31875     } catch (std::out_of_range& e) {
31876       {
31877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (std::exception& e) {
31880       {
31881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31882       };
31883     } catch (Dali::DaliException e) {
31884       {
31885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31886       };
31887     } catch (...) {
31888       {
31889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31890       };
31891     }
31892   }
31893
31894   jresult = (void *)result;
31895   return jresult;
31896 }
31897
31898
31899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31900   void * jresult ;
31901   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31902   Dali::LongPressGesture *arg2 = 0 ;
31903   Dali::LongPressGesture *result = 0 ;
31904
31905   arg1 = (Dali::LongPressGesture *)jarg1;
31906   arg2 = (Dali::LongPressGesture *)jarg2;
31907   if (!arg2) {
31908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31909     return 0;
31910   }
31911   {
31912     try {
31913       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31914     } catch (std::out_of_range& e) {
31915       {
31916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31917       };
31918     } catch (std::exception& e) {
31919       {
31920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31921       };
31922     } catch (Dali::DaliException e) {
31923       {
31924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31925       };
31926     } catch (...) {
31927       {
31928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31929       };
31930     }
31931   }
31932
31933   jresult = (void *)result;
31934   return jresult;
31935 }
31936
31937
31938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31939   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31940
31941   arg1 = (Dali::LongPressGesture *)jarg1;
31942   {
31943     try {
31944       delete arg1;
31945     } catch (std::out_of_range& e) {
31946       {
31947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31948       };
31949     } catch (std::exception& e) {
31950       {
31951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31952       };
31953     } catch (Dali::DaliException e) {
31954       {
31955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31956       };
31957     } catch (...) {
31958       {
31959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31960       };
31961     }
31962   }
31963
31964 }
31965
31966
31967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31968   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31969   unsigned int arg2 ;
31970
31971   arg1 = (Dali::LongPressGesture *)jarg1;
31972   arg2 = (unsigned int)jarg2;
31973   if (arg1) (arg1)->numberOfTouches = arg2;
31974 }
31975
31976
31977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31978   unsigned int jresult ;
31979   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31980   unsigned int result;
31981
31982   arg1 = (Dali::LongPressGesture *)jarg1;
31983   result = (unsigned int) ((arg1)->numberOfTouches);
31984   jresult = result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31990   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31991   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31992
31993   arg1 = (Dali::LongPressGesture *)jarg1;
31994   arg2 = (Dali::Vector2 *)jarg2;
31995   if (arg1) (arg1)->screenPoint = *arg2;
31996 }
31997
31998
31999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32000   void * jresult ;
32001   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32002   Dali::Vector2 *result = 0 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32006   jresult = (void *)result;
32007   return jresult;
32008 }
32009
32010
32011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32012   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32013   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32014
32015   arg1 = (Dali::LongPressGesture *)jarg1;
32016   arg2 = (Dali::Vector2 *)jarg2;
32017   if (arg1) (arg1)->localPoint = *arg2;
32018 }
32019
32020
32021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32022   void * jresult ;
32023   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32024   Dali::Vector2 *result = 0 ;
32025
32026   arg1 = (Dali::LongPressGesture *)jarg1;
32027   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32028   jresult = (void *)result;
32029   return jresult;
32030 }
32031
32032
32033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32034   void * jresult ;
32035   Dali::WheelEvent *result = 0 ;
32036
32037   {
32038     try {
32039       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32040     } catch (std::out_of_range& e) {
32041       {
32042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32043       };
32044     } catch (std::exception& e) {
32045       {
32046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32047       };
32048     } catch (Dali::DaliException e) {
32049       {
32050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32051       };
32052     } catch (...) {
32053       {
32054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32055       };
32056     }
32057   }
32058
32059   jresult = (void *)result;
32060   return jresult;
32061 }
32062
32063
32064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
32065   void * jresult ;
32066   Dali::WheelEvent *arg1 = 0 ;
32067   Dali::WheelEvent *result = 0 ;
32068
32069   arg1 = (Dali::WheelEvent *)jarg1;
32070   if (!arg1) {
32071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32072     return 0;
32073   }
32074   {
32075     try {
32076       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
32077     } catch (std::out_of_range& e) {
32078       {
32079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32080       };
32081     } catch (std::exception& e) {
32082       {
32083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32084       };
32085     } catch (Dali::DaliException e) {
32086       {
32087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32088       };
32089     } catch (...) {
32090       {
32091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32092       };
32093     }
32094   }
32095
32096   jresult = (void *)result;
32097   return jresult;
32098 }
32099
32100
32101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
32102   void * jresult ;
32103   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32104   Dali::WheelEvent *arg2 = 0 ;
32105   Dali::WheelEvent *result = 0 ;
32106
32107   arg1 = (Dali::WheelEvent *)jarg1;
32108   arg2 = (Dali::WheelEvent *)jarg2;
32109   if (!arg2) {
32110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32111     return 0;
32112   }
32113   {
32114     try {
32115       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
32116     } catch (std::out_of_range& e) {
32117       {
32118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32119       };
32120     } catch (std::exception& e) {
32121       {
32122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32123       };
32124     } catch (Dali::DaliException e) {
32125       {
32126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32127       };
32128     } catch (...) {
32129       {
32130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32131       };
32132     }
32133   }
32134
32135   jresult = (void *)result;
32136   return jresult;
32137 }
32138
32139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32140   void * jresult ;
32141   Dali::WheelEvent::Type arg1 ;
32142   int arg2 ;
32143   unsigned int arg3 ;
32144   Dali::Vector2 arg4 ;
32145   int arg5 ;
32146   unsigned int arg6 ;
32147   Dali::Vector2 *argp4 ;
32148   Dali::WheelEvent result;
32149
32150   arg1 = (Dali::WheelEvent::Type)jarg1;
32151   arg2 = (int)jarg2;
32152   arg3 = (unsigned int)jarg3;
32153   argp4 = (Dali::Vector2 *)jarg4;
32154   if (!argp4) {
32155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32156     return 0;
32157   }
32158   arg4 = *argp4;
32159   arg5 = (int)jarg5;
32160   arg6 = (unsigned int)jarg6;
32161   {
32162     try {
32163       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
32164     } catch (std::out_of_range& e) {
32165       {
32166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32167       };
32168     } catch (std::exception& e) {
32169       {
32170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32171       };
32172     } catch (Dali::DaliException e) {
32173       {
32174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32175       };
32176     } catch (...) {
32177       {
32178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32179       };
32180     }
32181   }
32182
32183   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
32184   return jresult;
32185 }
32186
32187
32188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32189   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32190
32191   arg1 = (Dali::WheelEvent *)jarg1;
32192   {
32193     try {
32194       delete arg1;
32195     } catch (std::out_of_range& e) {
32196       {
32197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32198       };
32199     } catch (std::exception& e) {
32200       {
32201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32202       };
32203     } catch (Dali::DaliException e) {
32204       {
32205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32206       };
32207     } catch (...) {
32208       {
32209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32210       };
32211     }
32212   }
32213
32214 }
32215
32216
32217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32218   unsigned int jresult ;
32219   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32220   bool result;
32221
32222   arg1 = (Dali::WheelEvent *)jarg1;
32223   {
32224     try {
32225       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32226     } catch (std::out_of_range& e) {
32227       {
32228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32229       };
32230     } catch (std::exception& e) {
32231       {
32232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32233       };
32234     } catch (Dali::DaliException e) {
32235       {
32236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32237       };
32238     } catch (...) {
32239       {
32240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32241       };
32242     }
32243   }
32244
32245   jresult = result;
32246   return jresult;
32247 }
32248
32249
32250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32251   unsigned int jresult ;
32252   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32253   bool result;
32254
32255   arg1 = (Dali::WheelEvent *)jarg1;
32256   {
32257     try {
32258       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32259     } catch (std::out_of_range& e) {
32260       {
32261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32262       };
32263     } catch (std::exception& e) {
32264       {
32265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32266       };
32267     } catch (Dali::DaliException e) {
32268       {
32269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32270       };
32271     } catch (...) {
32272       {
32273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32274       };
32275     }
32276   }
32277
32278   jresult = result;
32279   return jresult;
32280 }
32281
32282
32283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32284   unsigned int jresult ;
32285   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32286   bool result;
32287
32288   arg1 = (Dali::WheelEvent *)jarg1;
32289   {
32290     try {
32291       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32292     } catch (std::out_of_range& e) {
32293       {
32294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32295       };
32296     } catch (std::exception& e) {
32297       {
32298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32299       };
32300     } catch (Dali::DaliException e) {
32301       {
32302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32303       };
32304     } catch (...) {
32305       {
32306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32307       };
32308     }
32309   }
32310
32311   jresult = result;
32312   return jresult;
32313 }
32314
32315
32316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32317   int jresult ;
32318   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32319   Dali::WheelEvent::Type result;
32320
32321   arg1 = (Dali::WheelEvent *)jarg1;
32322   {
32323     try {
32324       result = ((Dali::WheelEvent const *)arg1)->GetType();
32325     } catch (std::out_of_range& e) {
32326       {
32327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32328       };
32329     } catch (std::exception& e) {
32330       {
32331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32332       };
32333     } catch (Dali::DaliException e) {
32334       {
32335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32336       };
32337     } catch (...) {
32338       {
32339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32340       };
32341     }
32342   }
32343
32344   jresult = (int)result;
32345   return jresult;
32346 }
32347
32348
32349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32350   int jresult ;
32351   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32352   int result;
32353
32354   arg1 = (Dali::WheelEvent *)jarg1;
32355   {
32356     try {
32357       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
32358     } catch (std::out_of_range& e) {
32359       {
32360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32361       };
32362     } catch (std::exception& e) {
32363       {
32364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32365       };
32366     } catch (Dali::DaliException e) {
32367       {
32368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32369       };
32370     } catch (...) {
32371       {
32372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32373       };
32374     }
32375   }
32376
32377   jresult = result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32383   unsigned int jresult ;
32384   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32385   unsigned int result;
32386
32387   arg1 = (Dali::WheelEvent *)jarg1;
32388   {
32389     try {
32390       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (Dali::DaliException e) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32402       };
32403     } catch (...) {
32404       {
32405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32406       };
32407     }
32408   }
32409
32410   jresult = result;
32411   return jresult;
32412 }
32413
32414
32415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32416   void * jresult ;
32417   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32418   Dali::Vector2 *result = 0 ;
32419
32420   arg1 = (Dali::WheelEvent *)jarg1;
32421   {
32422     try {
32423       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
32424     } catch (std::out_of_range& e) {
32425       {
32426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32427       };
32428     } catch (std::exception& e) {
32429       {
32430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32431       };
32432     } catch (Dali::DaliException e) {
32433       {
32434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32435       };
32436     } catch (...) {
32437       {
32438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32439       };
32440     }
32441   }
32442
32443   jresult = (void *)result;
32444   return jresult;
32445 }
32446
32447
32448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
32449   int jresult ;
32450   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32451   int result;
32452
32453   arg1 = (Dali::WheelEvent *)jarg1;
32454   {
32455     try {
32456       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
32457     } catch (std::out_of_range& e) {
32458       {
32459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32460       };
32461     } catch (std::exception& e) {
32462       {
32463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32464       };
32465     } catch (Dali::DaliException e) {
32466       {
32467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32468       };
32469     } catch (...) {
32470       {
32471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32472       };
32473     }
32474   }
32475
32476   jresult = result;
32477   return jresult;
32478 }
32479
32480
32481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32482   unsigned int jresult ;
32483   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32484   unsigned int result;
32485
32486   arg1 = (Dali::WheelEvent *)jarg1;
32487   {
32488     try {
32489       result = ((Dali::WheelEvent const *)arg1)->GetTime();
32490     } catch (std::out_of_range& e) {
32491       {
32492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32493       };
32494     } catch (std::exception& e) {
32495       {
32496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32497       };
32498     } catch (Dali::DaliException e) {
32499       {
32500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32501       };
32502     } catch (...) {
32503       {
32504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32505       };
32506     }
32507   }
32508
32509   jresult = result;
32510   return jresult;
32511 }
32512
32513 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32514   char * jresult ;
32515   Dali::KeyEvent *arg1 = 0 ;
32516   std::string result;
32517
32518   arg1 = (Dali::KeyEvent *)jarg1;
32519   if (!arg1) {
32520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32521     return 0;
32522   }
32523   {
32524     try {
32525       result = arg1->GetDeviceName();
32526     } catch (std::out_of_range& e) {
32527       {
32528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32529       };
32530     } catch (std::exception& e) {
32531       {
32532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32533       };
32534     } catch (Dali::DaliException e) {
32535       {
32536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32537       };
32538     } catch (...) {
32539       {
32540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32541       };
32542     }
32543   }
32544
32545   jresult = SWIG_csharp_string_callback((&result)->c_str());
32546   return jresult;
32547 }
32548
32549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32550   int jresult ;
32551   Dali::KeyEvent *arg1 = 0 ;
32552   Dali::Device::Class::Type result;
32553
32554   arg1 = (Dali::KeyEvent *)jarg1;
32555   if (!arg1) {
32556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32557     return 0;
32558   }
32559   {
32560     try {
32561       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32562     } catch (std::out_of_range& e) {
32563       {
32564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32565       };
32566     } catch (std::exception& e) {
32567       {
32568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32569       };
32570     } catch (Dali::DaliException e) {
32571       {
32572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32573       };
32574     } catch (...) {
32575       {
32576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32577       };
32578     }
32579   }
32580
32581   jresult = (int)result;
32582   return jresult;
32583 }
32584
32585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32586   int jresult ;
32587   Dali::KeyEvent *arg1 = 0 ;
32588   Dali::Device::Subclass::Type result;
32589
32590   arg1 = (Dali::KeyEvent *)jarg1;
32591   if (!arg1) {
32592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32593     return 0;
32594   }
32595   {
32596     try {
32597       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32598     } catch (std::out_of_range& e) {
32599       {
32600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32601       };
32602     } catch (std::exception& e) {
32603       {
32604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32605       };
32606     } catch (Dali::DaliException e) {
32607       {
32608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32609       };
32610     } catch (...) {
32611       {
32612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32613       };
32614     }
32615   }
32616
32617   jresult = (int)result;
32618   return jresult;
32619 }
32620
32621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32622   Dali::Actor arg1 ;
32623   Dali::Actor *argp1 ;
32624
32625   argp1 = (Dali::Actor *)jarg1;
32626   if (!argp1) {
32627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32628     return ;
32629   }
32630   arg1 = *argp1;
32631   {
32632     try {
32633       arg1.Raise();
32634     } catch (std::out_of_range& e) {
32635       {
32636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32637       };
32638     } catch (std::exception& e) {
32639       {
32640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32641       };
32642     } catch (Dali::DaliException e) {
32643       {
32644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32645       };
32646     } catch (...) {
32647       {
32648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32649       };
32650     }
32651   }
32652
32653 }
32654
32655
32656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32657   Dali::Actor arg1 ;
32658   Dali::Actor *argp1 ;
32659
32660   argp1 = (Dali::Actor *)jarg1;
32661   if (!argp1) {
32662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32663     return ;
32664   }
32665   arg1 = *argp1;
32666   {
32667     try {
32668       arg1.Lower();
32669     } catch (std::out_of_range& e) {
32670       {
32671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32672       };
32673     } catch (std::exception& e) {
32674       {
32675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32676       };
32677     } catch (Dali::DaliException e) {
32678       {
32679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32680       };
32681     } catch (...) {
32682       {
32683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32684       };
32685     }
32686   }
32687
32688 }
32689
32690
32691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32692   Dali::Actor arg1 ;
32693   Dali::Actor *argp1 ;
32694
32695   argp1 = (Dali::Actor *)jarg1;
32696   if (!argp1) {
32697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32698     return ;
32699   }
32700   arg1 = *argp1;
32701   {
32702     try {
32703       arg1.RaiseToTop();
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32711       };
32712     } catch (Dali::DaliException e) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32715       };
32716     } catch (...) {
32717       {
32718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32719       };
32720     }
32721   }
32722
32723 }
32724
32725
32726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32727   Dali::Actor arg1 ;
32728   Dali::Actor *argp1 ;
32729
32730   argp1 = (Dali::Actor *)jarg1;
32731   if (!argp1) {
32732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32733     return ;
32734   }
32735   arg1 = *argp1;
32736   {
32737     try {
32738       arg1.LowerToBottom();
32739     } catch (std::out_of_range& e) {
32740       {
32741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32742       };
32743     } catch (std::exception& e) {
32744       {
32745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32746       };
32747     } catch (Dali::DaliException e) {
32748       {
32749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32750       };
32751     } catch (...) {
32752       {
32753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32754       };
32755     }
32756   }
32757
32758 }
32759
32760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32761   Dali::Actor arg1 ;
32762   Dali::Actor arg2 ;
32763   Dali::Actor *argp1 ;
32764   Dali::Actor *argp2 ;
32765
32766   argp1 = (Dali::Actor *)jarg1;
32767   if (!argp1) {
32768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32769     return ;
32770   }
32771   arg1 = *argp1;
32772   argp2 = (Dali::Actor *)jarg2;
32773   if (!argp2) {
32774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32775     return ;
32776   }
32777   arg2 = *argp2;
32778   {
32779     try {
32780       arg1.RaiseAbove(arg2);
32781     } catch (std::out_of_range& e) {
32782       {
32783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32784       };
32785     } catch (std::exception& e) {
32786       {
32787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32788       };
32789     } catch (Dali::DaliException e) {
32790       {
32791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32792       };
32793     } catch (...) {
32794       {
32795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32796       };
32797     }
32798   }
32799
32800 }
32801
32802
32803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32804   Dali::Actor arg1 ;
32805   Dali::Actor arg2 ;
32806   Dali::Actor *argp1 ;
32807   Dali::Actor *argp2 ;
32808
32809   argp1 = (Dali::Actor *)jarg1;
32810   if (!argp1) {
32811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32812     return ;
32813   }
32814   arg1 = *argp1;
32815   argp2 = (Dali::Actor *)jarg2;
32816   if (!argp2) {
32817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32818     return ;
32819   }
32820   arg2 = *argp2;
32821   {
32822     try {
32823       arg1.LowerBelow(arg2);
32824     } catch (std::out_of_range& e) {
32825       {
32826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32827       };
32828     } catch (std::exception& e) {
32829       {
32830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32831       };
32832     } catch (Dali::DaliException e) {
32833       {
32834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32835       };
32836     } catch (...) {
32837       {
32838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32839       };
32840     }
32841   }
32842
32843 }
32844
32845
32846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32847   void * jresult ;
32848   Dali::Actor arg1 ;
32849   Dali::Actor *argp1 ;
32850   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32851
32852   argp1 = (Dali::Actor *)jarg1;
32853   if (!argp1) {
32854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32855     return 0;
32856   }
32857   arg1 = *argp1;
32858   {
32859     try {
32860       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32861     } catch (std::out_of_range& e) {
32862       {
32863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32864       };
32865     } catch (std::exception& e) {
32866       {
32867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32868       };
32869     } catch (Dali::DaliException e) {
32870       {
32871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32872       };
32873     } catch (...) {
32874       {
32875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32876       };
32877     }
32878   }
32879
32880   jresult = (void *)result;
32881   return jresult;
32882 }
32883
32884
32885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32886   void * jresult ;
32887   Dali::Actor *arg1 ;
32888   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32889
32890   arg1 = (Dali::Actor *)jarg1;
32891   {
32892     try {
32893       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32894     } catch (std::out_of_range& e) {
32895       {
32896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32897       };
32898     } catch (std::exception& e) {
32899       {
32900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32901       };
32902     } catch (Dali::DaliException e) {
32903       {
32904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32905       };
32906     } catch (...) {
32907       {
32908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32909       };
32910     }
32911   }
32912
32913   jresult = (void *)result;
32914   return jresult;
32915 }
32916
32917
32918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32919   int jresult ;
32920   int result;
32921
32922   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32923   jresult = (int)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32929   int jresult ;
32930   int result;
32931
32932   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32933   jresult = (int)result;
32934   return jresult;
32935 }
32936
32937
32938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32939   int jresult ;
32940   int result;
32941
32942   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32943   jresult = (int)result;
32944   return jresult;
32945 }
32946
32947
32948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32949   int jresult ;
32950   int result;
32951
32952   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32953   jresult = (int)result;
32954   return jresult;
32955 }
32956
32957
32958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32959   int jresult ;
32960   int result;
32961
32962   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32963   jresult = (int)result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32969   int jresult ;
32970   int result;
32971
32972   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32973   jresult = (int)result;
32974   return jresult;
32975 }
32976
32977
32978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32979   int jresult ;
32980   int result;
32981
32982   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32983   jresult = (int)result;
32984   return jresult;
32985 }
32986
32987
32988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32989   int jresult ;
32990   int result;
32991
32992   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32993   jresult = (int)result;
32994   return jresult;
32995 }
32996
32997
32998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32999   int jresult ;
33000   int result;
33001
33002   result = (int)Dali::Actor::Property::SIZE;
33003   jresult = (int)result;
33004   return jresult;
33005 }
33006
33007
33008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33009   int jresult ;
33010   int result;
33011
33012   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33013   jresult = (int)result;
33014   return jresult;
33015 }
33016
33017
33018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33019   int jresult ;
33020   int result;
33021
33022   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33023   jresult = (int)result;
33024   return jresult;
33025 }
33026
33027
33028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33029   int jresult ;
33030   int result;
33031
33032   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33033   jresult = (int)result;
33034   return jresult;
33035 }
33036
33037
33038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33039   int jresult ;
33040   int result;
33041
33042   result = (int)Dali::Actor::Property::POSITION;
33043   jresult = (int)result;
33044   return jresult;
33045 }
33046
33047
33048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33049   int jresult ;
33050   int result;
33051
33052   result = (int)Dali::Actor::Property::POSITION_X;
33053   jresult = (int)result;
33054   return jresult;
33055 }
33056
33057
33058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33059   int jresult ;
33060   int result;
33061
33062   result = (int)Dali::Actor::Property::POSITION_Y;
33063   jresult = (int)result;
33064   return jresult;
33065 }
33066
33067
33068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33069   int jresult ;
33070   int result;
33071
33072   result = (int)Dali::Actor::Property::POSITION_Z;
33073   jresult = (int)result;
33074   return jresult;
33075 }
33076
33077
33078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33079   int jresult ;
33080   int result;
33081
33082   result = (int)Dali::Actor::Property::WORLD_POSITION;
33083   jresult = (int)result;
33084   return jresult;
33085 }
33086
33087
33088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33089   int jresult ;
33090   int result;
33091
33092   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33093   jresult = (int)result;
33094   return jresult;
33095 }
33096
33097
33098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33099   int jresult ;
33100   int result;
33101
33102   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33103   jresult = (int)result;
33104   return jresult;
33105 }
33106
33107
33108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33109   int jresult ;
33110   int result;
33111
33112   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33113   jresult = (int)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33119   int jresult ;
33120   int result;
33121
33122   result = (int)Dali::Actor::Property::ORIENTATION;
33123   jresult = (int)result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33129   int jresult ;
33130   int result;
33131
33132   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33133   jresult = (int)result;
33134   return jresult;
33135 }
33136
33137
33138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33139   int jresult ;
33140   int result;
33141
33142   result = (int)Dali::Actor::Property::SCALE;
33143   jresult = (int)result;
33144   return jresult;
33145 }
33146
33147
33148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33149   int jresult ;
33150   int result;
33151
33152   result = (int)Dali::Actor::Property::SCALE_X;
33153   jresult = (int)result;
33154   return jresult;
33155 }
33156
33157
33158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33159   int jresult ;
33160   int result;
33161
33162   result = (int)Dali::Actor::Property::SCALE_Y;
33163   jresult = (int)result;
33164   return jresult;
33165 }
33166
33167
33168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33169   int jresult ;
33170   int result;
33171
33172   result = (int)Dali::Actor::Property::SCALE_Z;
33173   jresult = (int)result;
33174   return jresult;
33175 }
33176
33177
33178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33179   int jresult ;
33180   int result;
33181
33182   result = (int)Dali::Actor::Property::WORLD_SCALE;
33183   jresult = (int)result;
33184   return jresult;
33185 }
33186
33187
33188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33189   int jresult ;
33190   int result;
33191
33192   result = (int)Dali::Actor::Property::VISIBLE;
33193   jresult = (int)result;
33194   return jresult;
33195 }
33196
33197
33198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33199   int jresult ;
33200   int result;
33201
33202   result = (int)Dali::Actor::Property::COLOR;
33203   jresult = (int)result;
33204   return jresult;
33205 }
33206
33207
33208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33209   int jresult ;
33210   int result;
33211
33212   result = (int)Dali::Actor::Property::COLOR_RED;
33213   jresult = (int)result;
33214   return jresult;
33215 }
33216
33217
33218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33219   int jresult ;
33220   int result;
33221
33222   result = (int)Dali::Actor::Property::COLOR_GREEN;
33223   jresult = (int)result;
33224   return jresult;
33225 }
33226
33227
33228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33229   int jresult ;
33230   int result;
33231
33232   result = (int)Dali::Actor::Property::COLOR_BLUE;
33233   jresult = (int)result;
33234   return jresult;
33235 }
33236
33237
33238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33239   int jresult ;
33240   int result;
33241
33242   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33243   jresult = (int)result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33249   int jresult ;
33250   int result;
33251
33252   result = (int)Dali::Actor::Property::WORLD_COLOR;
33253   jresult = (int)result;
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33259   int jresult ;
33260   int result;
33261
33262   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33263   jresult = (int)result;
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33269   int jresult ;
33270   int result;
33271
33272   result = (int)Dali::Actor::Property::NAME;
33273   jresult = (int)result;
33274   return jresult;
33275 }
33276
33277
33278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33279   int jresult ;
33280   int result;
33281
33282   result = (int)Dali::Actor::Property::SENSITIVE;
33283   jresult = (int)result;
33284   return jresult;
33285 }
33286
33287
33288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33289   int jresult ;
33290   int result;
33291
33292   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33293   jresult = (int)result;
33294   return jresult;
33295 }
33296
33297
33298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33299   int jresult ;
33300   int result;
33301
33302   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33303   jresult = (int)result;
33304   return jresult;
33305 }
33306
33307
33308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33309   int jresult ;
33310   int result;
33311
33312   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33313   jresult = (int)result;
33314   return jresult;
33315 }
33316
33317
33318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33319   int jresult ;
33320   int result;
33321
33322   result = (int)Dali::Actor::Property::COLOR_MODE;
33323   jresult = (int)result;
33324   return jresult;
33325 }
33326
33327
33328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33329   int jresult ;
33330   int result;
33331
33332   result = (int)Dali::Actor::Property::DRAW_MODE;
33333   jresult = (int)result;
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33339   int jresult ;
33340   int result;
33341
33342   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33343   jresult = (int)result;
33344   return jresult;
33345 }
33346
33347
33348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33349   int jresult ;
33350   int result;
33351
33352   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33353   jresult = (int)result;
33354   return jresult;
33355 }
33356
33357
33358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33359   int jresult ;
33360   int result;
33361
33362   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33363   jresult = (int)result;
33364   return jresult;
33365 }
33366
33367
33368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33369   int jresult ;
33370   int result;
33371
33372   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33373   jresult = (int)result;
33374   return jresult;
33375 }
33376
33377
33378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33379   int jresult ;
33380   int result;
33381
33382   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33383   jresult = (int)result;
33384   return jresult;
33385 }
33386
33387
33388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33389   int jresult ;
33390   int result;
33391
33392   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33393   jresult = (int)result;
33394   return jresult;
33395 }
33396
33397
33398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33399   int jresult ;
33400   int result;
33401
33402   result = (int)Dali::Actor::Property::PADDING;
33403   jresult = (int)result;
33404   return jresult;
33405 }
33406
33407
33408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33409   int jresult ;
33410   int result;
33411
33412   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33413   jresult = (int)result;
33414   return jresult;
33415 }
33416
33417
33418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33419   int jresult ;
33420   int result;
33421
33422   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33423   jresult = (int)result;
33424   return jresult;
33425 }
33426
33427
33428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33429   int jresult ;
33430   int result;
33431
33432   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33433   jresult = (int)result;
33434   return jresult;
33435 }
33436
33437
33438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33439   int jresult ;
33440   int result;
33441
33442   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33443   jresult = (int)result;
33444   return jresult;
33445 }
33446
33447 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33448
33449   return Dali::Actor::Property::OPACITY;
33450 }
33451
33452 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33453
33454   return Dali::Actor::Property::SCREEN_POSITION;
33455 }
33456
33457 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33458
33459   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33460 }
33461
33462 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33463   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33464 }
33465
33466 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33467   return Dali::Actor::Property::LAYOUT_DIRECTION;
33468 }
33469
33470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33471   void * jresult ;
33472   Dali::Actor::Property *result = 0 ;
33473
33474   {
33475     try {
33476       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33477     } catch (std::out_of_range& e) {
33478       {
33479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (std::exception& e) {
33482       {
33483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (Dali::DaliException e) {
33486       {
33487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33488       };
33489     } catch (...) {
33490       {
33491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33492       };
33493     }
33494   }
33495
33496   jresult = (void *)result;
33497   return jresult;
33498 }
33499
33500
33501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33502   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33503
33504   arg1 = (Dali::Actor::Property *)jarg1;
33505   {
33506     try {
33507       delete arg1;
33508     } catch (std::out_of_range& e) {
33509       {
33510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33511       };
33512     } catch (std::exception& e) {
33513       {
33514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33515       };
33516     } catch (Dali::DaliException e) {
33517       {
33518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33519       };
33520     } catch (...) {
33521       {
33522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33523       };
33524     }
33525   }
33526
33527 }
33528
33529
33530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33531   void * jresult ;
33532   Dali::Actor *result = 0 ;
33533
33534   {
33535     try {
33536       result = (Dali::Actor *)new Dali::Actor();
33537     } catch (std::out_of_range& e) {
33538       {
33539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33540       };
33541     } catch (std::exception& e) {
33542       {
33543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33544       };
33545     } catch (Dali::DaliException e) {
33546       {
33547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33548       };
33549     } catch (...) {
33550       {
33551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33552       };
33553     }
33554   }
33555
33556   jresult = (void *)result;
33557   return jresult;
33558 }
33559
33560
33561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33562   void * jresult ;
33563   Dali::Actor result;
33564
33565   {
33566     try {
33567       result = Dali::Actor::New();
33568     } catch (std::out_of_range& e) {
33569       {
33570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33571       };
33572     } catch (std::exception& e) {
33573       {
33574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33575       };
33576     } catch (Dali::DaliException e) {
33577       {
33578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33579       };
33580     } catch (...) {
33581       {
33582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33583       };
33584     }
33585   }
33586
33587   jresult = new Dali::Actor((const Dali::Actor &)result);
33588   return jresult;
33589 }
33590
33591
33592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33593   void * jresult ;
33594   Dali::BaseHandle arg1 ;
33595   Dali::BaseHandle *argp1 ;
33596   Dali::Actor result;
33597
33598   argp1 = (Dali::BaseHandle *)jarg1;
33599   if (!argp1) {
33600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33601     return 0;
33602   }
33603   arg1 = *argp1;
33604   {
33605     try {
33606       result = Dali::Actor::DownCast(arg1);
33607     } catch (std::out_of_range& e) {
33608       {
33609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33610       };
33611     } catch (std::exception& e) {
33612       {
33613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33614       };
33615     } catch (Dali::DaliException e) {
33616       {
33617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33618       };
33619     } catch (...) {
33620       {
33621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33622       };
33623     }
33624   }
33625
33626   jresult = new Dali::Actor((const Dali::Actor &)result);
33627   return jresult;
33628 }
33629
33630
33631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33633
33634   arg1 = (Dali::Actor *)jarg1;
33635   {
33636     try {
33637       delete arg1;
33638     } catch (std::out_of_range& e) {
33639       {
33640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33641       };
33642     } catch (std::exception& e) {
33643       {
33644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33645       };
33646     } catch (Dali::DaliException e) {
33647       {
33648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33649       };
33650     } catch (...) {
33651       {
33652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33653       };
33654     }
33655   }
33656
33657 }
33658
33659
33660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33661   void * jresult ;
33662   Dali::Actor *arg1 = 0 ;
33663   Dali::Actor *result = 0 ;
33664
33665   arg1 = (Dali::Actor *)jarg1;
33666   if (!arg1) {
33667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33668     return 0;
33669   }
33670   {
33671     try {
33672       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33673     } catch (std::out_of_range& e) {
33674       {
33675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33676       };
33677     } catch (std::exception& e) {
33678       {
33679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33680       };
33681     } catch (Dali::DaliException e) {
33682       {
33683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33688       };
33689     }
33690   }
33691
33692   jresult = (void *)result;
33693   return jresult;
33694 }
33695
33696
33697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33698   void * jresult ;
33699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33700   Dali::Actor *arg2 = 0 ;
33701   Dali::Actor *result = 0 ;
33702
33703   arg1 = (Dali::Actor *)jarg1;
33704   arg2 = (Dali::Actor *)jarg2;
33705   if (!arg2) {
33706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33707     return 0;
33708   }
33709   {
33710     try {
33711       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33712     } catch (std::out_of_range& e) {
33713       {
33714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33715       };
33716     } catch (std::exception& e) {
33717       {
33718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (Dali::DaliException e) {
33721       {
33722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33723       };
33724     } catch (...) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33727       };
33728     }
33729   }
33730
33731   jresult = (void *)result;
33732   return jresult;
33733 }
33734
33735
33736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33737   char * jresult ;
33738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33739   std::string *result = 0 ;
33740
33741   arg1 = (Dali::Actor *)jarg1;
33742   {
33743     try {
33744       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33745       result = (std::string *) &name;
33746     } catch (std::out_of_range& e) {
33747       {
33748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33749       };
33750     } catch (std::exception& e) {
33751       {
33752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33753       };
33754     } catch (Dali::DaliException e) {
33755       {
33756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33761       };
33762     }
33763   }
33764
33765   jresult = SWIG_csharp_string_callback(result->c_str());
33766   return jresult;
33767 }
33768
33769
33770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33772   std::string *arg2 = 0 ;
33773
33774   arg1 = (Dali::Actor *)jarg1;
33775   if (!jarg2) {
33776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33777     return ;
33778   }
33779   std::string arg2_str(jarg2);
33780   arg2 = &arg2_str;
33781   {
33782     try {
33783       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33784     } catch (std::out_of_range& e) {
33785       {
33786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33787       };
33788     } catch (std::exception& e) {
33789       {
33790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33791       };
33792     } catch (Dali::DaliException e) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33799       };
33800     }
33801   }
33802
33803
33804   //argout typemap for const std::string&
33805
33806 }
33807
33808
33809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33810   unsigned int jresult ;
33811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33812   unsigned int result;
33813
33814   arg1 = (Dali::Actor *)jarg1;
33815
33816   if(!arg1) {
33817     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33818     return -1;
33819   }
33820
33821   {
33822     try {
33823       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33824     } catch (std::out_of_range& e) {
33825       {
33826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33827       };
33828     } catch (std::exception& e) {
33829       {
33830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33831       };
33832     } catch (Dali::DaliException e) {
33833       {
33834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33835       };
33836     } catch (...) {
33837       {
33838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33839       };
33840     }
33841   }
33842
33843   jresult = result;
33844   return jresult;
33845 }
33846
33847
33848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33849   unsigned int jresult ;
33850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33851   bool result;
33852
33853   arg1 = (Dali::Actor *)jarg1;
33854   {
33855     try {
33856       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33857     } catch (std::out_of_range& e) {
33858       {
33859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33860       };
33861     } catch (std::exception& e) {
33862       {
33863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33864       };
33865     } catch (Dali::DaliException e) {
33866       {
33867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33868       };
33869     } catch (...) {
33870       {
33871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33872       };
33873     }
33874   }
33875
33876   jresult = result;
33877   return jresult;
33878 }
33879
33880
33881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33882   unsigned int jresult ;
33883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33884   bool result;
33885
33886   arg1 = (Dali::Actor *)jarg1;
33887   {
33888     try {
33889       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33890     } catch (std::out_of_range& e) {
33891       {
33892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (std::exception& e) {
33895       {
33896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33897       };
33898     } catch (Dali::DaliException e) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33901       };
33902     } catch (...) {
33903       {
33904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33905       };
33906     }
33907   }
33908
33909   jresult = result;
33910   return jresult;
33911 }
33912
33913
33914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33915   unsigned int jresult ;
33916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33917   bool result;
33918
33919   arg1 = (Dali::Actor *)jarg1;
33920   {
33921     try {
33922       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33923     } catch (std::out_of_range& e) {
33924       {
33925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33926       };
33927     } catch (std::exception& e) {
33928       {
33929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33930       };
33931     } catch (Dali::DaliException e) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33934       };
33935     } catch (...) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33938       };
33939     }
33940   }
33941
33942   jresult = result;
33943   return jresult;
33944 }
33945
33946
33947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33948   void * jresult ;
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950   Dali::Layer result;
33951
33952   arg1 = (Dali::Actor *)jarg1;
33953   {
33954     try {
33955       result = (arg1)->GetLayer();
33956     } catch (std::out_of_range& e) {
33957       {
33958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33959       };
33960     } catch (std::exception& e) {
33961       {
33962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33963       };
33964     } catch (Dali::DaliException e) {
33965       {
33966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33967       };
33968     } catch (...) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33971       };
33972     }
33973   }
33974
33975   jresult = new Dali::Layer((const Dali::Layer &)result);
33976   return jresult;
33977 }
33978
33979
33980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33982   Dali::Actor arg2 ;
33983   Dali::Actor *argp2 ;
33984
33985   arg1 = (Dali::Actor *)jarg1;
33986   argp2 = (Dali::Actor *)jarg2;
33987   if (!argp2) {
33988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33989     return ;
33990   }
33991   arg2 = *argp2;
33992   {
33993     try {
33994       (arg1)->Add(arg2);
33995     } catch (std::out_of_range& e) {
33996       {
33997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33998       };
33999     } catch (std::exception& e) {
34000       {
34001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34002       };
34003     } catch (Dali::DaliException e) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34006       };
34007     } catch (...) {
34008       {
34009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34010       };
34011     }
34012   }
34013
34014 }
34015
34016
34017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34019   Dali::Actor arg2 ;
34020   Dali::Actor *argp2 ;
34021
34022   arg1 = (Dali::Actor *)jarg1;
34023   argp2 = (Dali::Actor *)jarg2;
34024   if (!argp2) {
34025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34026     return ;
34027   }
34028   arg2 = *argp2;
34029   {
34030     try {
34031       (arg1)->Remove(arg2);
34032     } catch (std::out_of_range& e) {
34033       {
34034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34035       };
34036     } catch (std::exception& e) {
34037       {
34038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34039       };
34040     } catch (Dali::DaliException e) {
34041       {
34042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34043       };
34044     } catch (...) {
34045       {
34046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34047       };
34048     }
34049   }
34050
34051 }
34052
34053
34054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34056
34057   arg1 = (Dali::Actor *)jarg1;
34058   {
34059     try {
34060       (arg1)->Unparent();
34061     } catch (std::out_of_range& e) {
34062       {
34063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34064       };
34065     } catch (std::exception& e) {
34066       {
34067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34068       };
34069     } catch (Dali::DaliException e) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34072       };
34073     } catch (...) {
34074       {
34075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34076       };
34077     }
34078   }
34079
34080 }
34081
34082
34083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34084   unsigned int jresult ;
34085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34086   unsigned int result;
34087
34088   arg1 = (Dali::Actor *)jarg1;
34089   {
34090     try {
34091       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34092     } catch (std::out_of_range& e) {
34093       {
34094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34095       };
34096     } catch (std::exception& e) {
34097       {
34098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34099       };
34100     } catch (Dali::DaliException e) {
34101       {
34102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34103       };
34104     } catch (...) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34107       };
34108     }
34109   }
34110
34111   jresult = result;
34112   return jresult;
34113 }
34114
34115
34116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34117   void * jresult ;
34118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34119   unsigned int arg2 ;
34120   Dali::Actor result;
34121
34122   arg1 = (Dali::Actor *)jarg1;
34123   arg2 = (unsigned int)jarg2;
34124   {
34125     try {
34126       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (Dali::DaliException e) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34138       };
34139     } catch (...) {
34140       {
34141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34142       };
34143     }
34144   }
34145
34146   jresult = new Dali::Actor((const Dali::Actor &)result);
34147   return jresult;
34148 }
34149
34150
34151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34152   void * jresult ;
34153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34154   std::string *arg2 = 0 ;
34155   Dali::Actor result;
34156
34157   arg1 = (Dali::Actor *)jarg1;
34158   if (!jarg2) {
34159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34160     return 0;
34161   }
34162   std::string arg2_str(jarg2);
34163   arg2 = &arg2_str;
34164   {
34165     try {
34166       result = (arg1)->FindChildByName((std::string const &)*arg2);
34167     } catch (std::out_of_range& e) {
34168       {
34169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34170       };
34171     } catch (std::exception& e) {
34172       {
34173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34174       };
34175     } catch (Dali::DaliException e) {
34176       {
34177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34182       };
34183     }
34184   }
34185
34186   jresult = new Dali::Actor((const Dali::Actor &)result);
34187
34188   //argout typemap for const std::string&
34189
34190   return jresult;
34191 }
34192
34193
34194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34195   void * jresult ;
34196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34197   unsigned int arg2 ;
34198   Dali::Actor result;
34199
34200   arg1 = (Dali::Actor *)jarg1;
34201   arg2 = (unsigned int)jarg2;
34202   {
34203     try {
34204       result = (arg1)->FindChildById(arg2);
34205     } catch (std::out_of_range& e) {
34206       {
34207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34208       };
34209     } catch (std::exception& e) {
34210       {
34211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34212       };
34213     } catch (Dali::DaliException e) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34216       };
34217     } catch (...) {
34218       {
34219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34220       };
34221     }
34222   }
34223
34224   jresult = new Dali::Actor((const Dali::Actor &)result);
34225   return jresult;
34226 }
34227
34228
34229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34230   void * jresult ;
34231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34232   Dali::Actor result;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   {
34236     try {
34237       result = ((Dali::Actor const *)arg1)->GetParent();
34238     } catch (std::out_of_range& e) {
34239       {
34240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34241       };
34242     } catch (std::exception& e) {
34243       {
34244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34245       };
34246     } catch (Dali::DaliException e) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34253       };
34254     }
34255   }
34256
34257   jresult = new Dali::Actor((const Dali::Actor &)result);
34258   return jresult;
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34263   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34264   Dali::Vector3 *arg2 = 0 ;
34265
34266   arg1 = (Dali::Actor *)jarg1;
34267   arg2 = (Dali::Vector3 *)jarg2;
34268   if (!arg2) {
34269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34270     return ;
34271   }
34272   {
34273     try {
34274       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34275     } catch (std::out_of_range& e) {
34276       {
34277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (std::exception& e) {
34280       {
34281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34282       };
34283     } catch (Dali::DaliException e) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34286       };
34287     } catch (...) {
34288       {
34289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34290       };
34291     }
34292   }
34293
34294 }
34295
34296
34297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34298   void * jresult ;
34299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34300   Dali::Vector3 result;
34301
34302   arg1 = (Dali::Actor *)jarg1;
34303   {
34304     try {
34305       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34306     } catch (std::out_of_range& e) {
34307       {
34308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34309       };
34310     } catch (std::exception& e) {
34311       {
34312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34313       };
34314     } catch (Dali::DaliException e) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34317       };
34318     } catch (...) {
34319       {
34320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34321       };
34322     }
34323   }
34324
34325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34326   return jresult;
34327 }
34328
34329
34330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34331   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34332   Dali::Vector3 *arg2 = 0 ;
34333
34334   arg1 = (Dali::Actor *)jarg1;
34335   arg2 = (Dali::Vector3 *)jarg2;
34336   if (!arg2) {
34337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34338     return ;
34339   }
34340   {
34341     try {
34342       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34343     } catch (std::out_of_range& e) {
34344       {
34345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34346       };
34347     } catch (std::exception& e) {
34348       {
34349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34350       };
34351     } catch (Dali::DaliException e) {
34352       {
34353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34354       };
34355     } catch (...) {
34356       {
34357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34358       };
34359     }
34360   }
34361
34362 }
34363
34364
34365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34366   void * jresult ;
34367   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34368   Dali::Vector3 result;
34369
34370   arg1 = (Dali::Actor *)jarg1;
34371   {
34372     try {
34373       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34374     } catch (std::out_of_range& e) {
34375       {
34376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34377       };
34378     } catch (std::exception& e) {
34379       {
34380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34381       };
34382     } catch (Dali::DaliException e) {
34383       {
34384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34385       };
34386     } catch (...) {
34387       {
34388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34389       };
34390     }
34391   }
34392
34393   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34394   return jresult;
34395 }
34396
34397
34398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34400   float arg2 ;
34401   float arg3 ;
34402
34403   arg1 = (Dali::Actor *)jarg1;
34404   arg2 = (float)jarg2;
34405   arg3 = (float)jarg3;
34406   {
34407     try {
34408       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34409     } catch (std::out_of_range& e) {
34410       {
34411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34412       };
34413     } catch (std::exception& e) {
34414       {
34415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34416       };
34417     } catch (Dali::DaliException e) {
34418       {
34419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34420       };
34421     } catch (...) {
34422       {
34423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34424       };
34425     }
34426   }
34427
34428 }
34429
34430
34431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34433   float arg2 ;
34434   float arg3 ;
34435   float arg4 ;
34436
34437   arg1 = (Dali::Actor *)jarg1;
34438   arg2 = (float)jarg2;
34439   arg3 = (float)jarg3;
34440   arg4 = (float)jarg4;
34441   {
34442     try {
34443       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34444     } catch (std::out_of_range& e) {
34445       {
34446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34447       };
34448     } catch (std::exception& e) {
34449       {
34450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34451       };
34452     } catch (Dali::DaliException e) {
34453       {
34454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34455       };
34456     } catch (...) {
34457       {
34458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34459       };
34460     }
34461   }
34462
34463 }
34464
34465
34466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34468   Dali::Vector2 *arg2 = 0 ;
34469
34470   arg1 = (Dali::Actor *)jarg1;
34471   arg2 = (Dali::Vector2 *)jarg2;
34472   if (!arg2) {
34473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34474     return ;
34475   }
34476   {
34477     try {
34478       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34479     } catch (std::out_of_range& e) {
34480       {
34481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34482       };
34483     } catch (std::exception& e) {
34484       {
34485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34486       };
34487     } catch (Dali::DaliException e) {
34488       {
34489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34490       };
34491     } catch (...) {
34492       {
34493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34494       };
34495     }
34496   }
34497
34498 }
34499
34500
34501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34502   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34503   Dali::Vector3 *arg2 = 0 ;
34504
34505   arg1 = (Dali::Actor *)jarg1;
34506   arg2 = (Dali::Vector3 *)jarg2;
34507   if (!arg2) {
34508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34509     return ;
34510   }
34511   {
34512     try {
34513       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34514     } catch (std::out_of_range& e) {
34515       {
34516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34517       };
34518     } catch (std::exception& e) {
34519       {
34520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34521       };
34522     } catch (Dali::DaliException e) {
34523       {
34524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34525       };
34526     } catch (...) {
34527       {
34528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34529       };
34530     }
34531   }
34532
34533 }
34534
34535
34536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34537   void * jresult ;
34538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34539   Dali::Vector3 result;
34540
34541   arg1 = (Dali::Actor *)jarg1;
34542   {
34543     try {
34544       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34545     } catch (std::out_of_range& e) {
34546       {
34547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34548       };
34549     } catch (std::exception& e) {
34550       {
34551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34552       };
34553     } catch (Dali::DaliException e) {
34554       {
34555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34556       };
34557     } catch (...) {
34558       {
34559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34560       };
34561     }
34562   }
34563
34564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34565   return jresult;
34566 }
34567
34568
34569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34570   void * jresult ;
34571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34572   Dali::Vector3 result;
34573
34574   arg1 = (Dali::Actor *)jarg1;
34575   {
34576     try {
34577       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34578     } catch (std::out_of_range& e) {
34579       {
34580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34581       };
34582     } catch (std::exception& e) {
34583       {
34584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34585       };
34586     } catch (Dali::DaliException e) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34589       };
34590     } catch (...) {
34591       {
34592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34593       };
34594     }
34595   }
34596
34597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34598   return jresult;
34599 }
34600
34601
34602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34603   void * jresult ;
34604   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34605   Dali::Vector3 result;
34606
34607   arg1 = (Dali::Actor *)jarg1;
34608   {
34609     try {
34610       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34611     } catch (std::out_of_range& e) {
34612       {
34613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34614       };
34615     } catch (std::exception& e) {
34616       {
34617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34618       };
34619     } catch (Dali::DaliException e) {
34620       {
34621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34622       };
34623     } catch (...) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34626       };
34627     }
34628   }
34629
34630   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34631   return jresult;
34632 }
34633
34634
34635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34637   float arg2 ;
34638   float arg3 ;
34639
34640   arg1 = (Dali::Actor *)jarg1;
34641   arg2 = (float)jarg2;
34642   arg3 = (float)jarg3;
34643   {
34644     try {
34645       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34653       };
34654     } catch (Dali::DaliException e) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34657       };
34658     } catch (...) {
34659       {
34660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34661       };
34662     }
34663   }
34664
34665 }
34666
34667
34668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34670   float arg2 ;
34671   float arg3 ;
34672   float arg4 ;
34673
34674   arg1 = (Dali::Actor *)jarg1;
34675   arg2 = (float)jarg2;
34676   arg3 = (float)jarg3;
34677   arg4 = (float)jarg4;
34678   {
34679     try {
34680       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34688       };
34689     } catch (Dali::DaliException e) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34692       };
34693     } catch (...) {
34694       {
34695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34696       };
34697     }
34698   }
34699
34700 }
34701
34702
34703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34705   Dali::Vector3 *arg2 = 0 ;
34706
34707   arg1 = (Dali::Actor *)jarg1;
34708   arg2 = (Dali::Vector3 *)jarg2;
34709   if (!arg2) {
34710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34711     return ;
34712   }
34713   {
34714     try {
34715       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34716     } catch (std::out_of_range& e) {
34717       {
34718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34719       };
34720     } catch (std::exception& e) {
34721       {
34722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34723       };
34724     } catch (Dali::DaliException e) {
34725       {
34726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34727       };
34728     } catch (...) {
34729       {
34730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34731       };
34732     }
34733   }
34734
34735 }
34736
34737
34738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34740   float arg2 ;
34741
34742   arg1 = (Dali::Actor *)jarg1;
34743   arg2 = (float)jarg2;
34744   {
34745     try {
34746       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34754       };
34755     } catch (Dali::DaliException e) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34758       };
34759     } catch (...) {
34760       {
34761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34762       };
34763     }
34764   }
34765
34766 }
34767
34768
34769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34771   float arg2 ;
34772
34773   arg1 = (Dali::Actor *)jarg1;
34774   arg2 = (float)jarg2;
34775   {
34776     try {
34777       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34778     } catch (std::out_of_range& e) {
34779       {
34780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34781       };
34782     } catch (std::exception& e) {
34783       {
34784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34785       };
34786     } catch (Dali::DaliException e) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34789       };
34790     } catch (...) {
34791       {
34792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34793       };
34794     }
34795   }
34796
34797 }
34798
34799
34800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34802   float arg2 ;
34803
34804   arg1 = (Dali::Actor *)jarg1;
34805   arg2 = (float)jarg2;
34806   {
34807     try {
34808       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34809     } catch (std::out_of_range& e) {
34810       {
34811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34812       };
34813     } catch (std::exception& e) {
34814       {
34815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34816       };
34817     } catch (Dali::DaliException e) {
34818       {
34819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34824       };
34825     }
34826   }
34827
34828 }
34829
34830
34831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34833   Dali::Vector3 *arg2 = 0 ;
34834
34835   arg1 = (Dali::Actor *)jarg1;
34836   arg2 = (Dali::Vector3 *)jarg2;
34837   if (!arg2) {
34838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34839     return ;
34840   }
34841   {
34842     try {
34843       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34844     } catch (std::out_of_range& e) {
34845       {
34846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (std::exception& e) {
34849       {
34850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34851       };
34852     } catch (Dali::DaliException e) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34855       };
34856     } catch (...) {
34857       {
34858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34859       };
34860     }
34861   }
34862
34863 }
34864
34865
34866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34867   void * jresult ;
34868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34869   Dali::Vector3 result;
34870
34871   arg1 = (Dali::Actor *)jarg1;
34872   {
34873     try {
34874       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34875     } catch (std::out_of_range& e) {
34876       {
34877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (std::exception& e) {
34880       {
34881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34882       };
34883     } catch (Dali::DaliException e) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34886       };
34887     } catch (...) {
34888       {
34889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34890       };
34891     }
34892   }
34893
34894   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34895   return jresult;
34896 }
34897
34898
34899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34900   void * jresult ;
34901   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34902   Dali::Vector3 result;
34903
34904   arg1 = (Dali::Actor *)jarg1;
34905   {
34906     try {
34907       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34908     } catch (std::out_of_range& e) {
34909       {
34910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34911       };
34912     } catch (std::exception& e) {
34913       {
34914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34915       };
34916     } catch (Dali::DaliException e) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34919       };
34920     } catch (...) {
34921       {
34922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34923       };
34924     }
34925   }
34926
34927   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34928   return jresult;
34929 }
34930
34931
34932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34934   bool arg2 ;
34935
34936   arg1 = (Dali::Actor *)jarg1;
34937   arg2 = jarg2 ? true : false;
34938   {
34939     try {
34940       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34941     } catch (std::out_of_range& e) {
34942       {
34943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34944       };
34945     } catch (std::exception& e) {
34946       {
34947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34948       };
34949     } catch (Dali::DaliException e) {
34950       {
34951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34952       };
34953     } catch (...) {
34954       {
34955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34956       };
34957     }
34958   }
34959
34960 }
34961
34962
34963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34964   unsigned int jresult ;
34965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34966   bool result;
34967
34968   arg1 = (Dali::Actor *)jarg1;
34969   {
34970     try {
34971       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34972     } catch (std::out_of_range& e) {
34973       {
34974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34975       };
34976     } catch (std::exception& e) {
34977       {
34978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34979       };
34980     } catch (Dali::DaliException e) {
34981       {
34982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34983       };
34984     } catch (...) {
34985       {
34986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34987       };
34988     }
34989   }
34990
34991   jresult = result;
34992   return jresult;
34993 }
34994
34995
34996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34997   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34998   Dali::Degree *arg2 = 0 ;
34999   Dali::Vector3 *arg3 = 0 ;
35000
35001   arg1 = (Dali::Actor *)jarg1;
35002   arg2 = (Dali::Degree *)jarg2;
35003   if (!arg2) {
35004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35005     return ;
35006   }
35007   arg3 = (Dali::Vector3 *)jarg3;
35008   if (!arg3) {
35009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35010     return ;
35011   }
35012   {
35013     try {
35014       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35015     } catch (std::out_of_range& e) {
35016       {
35017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35018       };
35019     } catch (std::exception& e) {
35020       {
35021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35022       };
35023     } catch (Dali::DaliException e) {
35024       {
35025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35026       };
35027     } catch (...) {
35028       {
35029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35030       };
35031     }
35032   }
35033
35034 }
35035
35036
35037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35038   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35039   Dali::Radian *arg2 = 0 ;
35040   Dali::Vector3 *arg3 = 0 ;
35041
35042   arg1 = (Dali::Actor *)jarg1;
35043   arg2 = (Dali::Radian *)jarg2;
35044   if (!arg2) {
35045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35046     return ;
35047   }
35048   arg3 = (Dali::Vector3 *)jarg3;
35049   if (!arg3) {
35050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35051     return ;
35052   }
35053   {
35054     try {
35055       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
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_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35080   Dali::Quaternion *arg2 = 0 ;
35081
35082   arg1 = (Dali::Actor *)jarg1;
35083   arg2 = (Dali::Quaternion *)jarg2;
35084   if (!arg2) {
35085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35086     return ;
35087   }
35088   {
35089     try {
35090       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35091     } catch (std::out_of_range& e) {
35092       {
35093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (std::exception& e) {
35096       {
35097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35098       };
35099     } catch (Dali::DaliException e) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35102       };
35103     } catch (...) {
35104       {
35105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35106       };
35107     }
35108   }
35109
35110 }
35111
35112
35113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35115   Dali::Degree *arg2 = 0 ;
35116   Dali::Vector3 *arg3 = 0 ;
35117
35118   arg1 = (Dali::Actor *)jarg1;
35119   arg2 = (Dali::Degree *)jarg2;
35120   if (!arg2) {
35121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35122     return ;
35123   }
35124   arg3 = (Dali::Vector3 *)jarg3;
35125   if (!arg3) {
35126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35127     return ;
35128   }
35129   {
35130     try {
35131       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35132     } catch (std::out_of_range& e) {
35133       {
35134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35135       };
35136     } catch (std::exception& e) {
35137       {
35138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35139       };
35140     } catch (Dali::DaliException e) {
35141       {
35142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35143       };
35144     } catch (...) {
35145       {
35146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35147       };
35148     }
35149   }
35150
35151 }
35152
35153
35154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35156   Dali::Radian *arg2 = 0 ;
35157   Dali::Vector3 *arg3 = 0 ;
35158
35159   arg1 = (Dali::Actor *)jarg1;
35160   arg2 = (Dali::Radian *)jarg2;
35161   if (!arg2) {
35162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35163     return ;
35164   }
35165   arg3 = (Dali::Vector3 *)jarg3;
35166   if (!arg3) {
35167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35168     return ;
35169   }
35170   {
35171     try {
35172       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35173     } catch (std::out_of_range& e) {
35174       {
35175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35176       };
35177     } catch (std::exception& e) {
35178       {
35179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35180       };
35181     } catch (Dali::DaliException e) {
35182       {
35183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35184       };
35185     } catch (...) {
35186       {
35187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35188       };
35189     }
35190   }
35191
35192 }
35193
35194
35195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35197   Dali::Quaternion *arg2 = 0 ;
35198
35199   arg1 = (Dali::Actor *)jarg1;
35200   arg2 = (Dali::Quaternion *)jarg2;
35201   if (!arg2) {
35202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35203     return ;
35204   }
35205   {
35206     try {
35207       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35208     } catch (std::out_of_range& e) {
35209       {
35210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35211       };
35212     } catch (std::exception& e) {
35213       {
35214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35215       };
35216     } catch (Dali::DaliException e) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35219       };
35220     } catch (...) {
35221       {
35222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35223       };
35224     }
35225   }
35226
35227 }
35228
35229
35230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35231   void * jresult ;
35232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35233   Dali::Quaternion result;
35234
35235   arg1 = (Dali::Actor *)jarg1;
35236   {
35237     try {
35238       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35239     } catch (std::out_of_range& e) {
35240       {
35241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35242       };
35243     } catch (std::exception& e) {
35244       {
35245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35246       };
35247     } catch (Dali::DaliException e) {
35248       {
35249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35250       };
35251     } catch (...) {
35252       {
35253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35254       };
35255     }
35256   }
35257
35258   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35259   return jresult;
35260 }
35261
35262
35263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35264   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35265   bool arg2 ;
35266
35267   arg1 = (Dali::Actor *)jarg1;
35268   arg2 = jarg2 ? true : false;
35269   {
35270     try {
35271       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35272     } catch (std::out_of_range& e) {
35273       {
35274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35275       };
35276     } catch (std::exception& e) {
35277       {
35278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35279       };
35280     } catch (Dali::DaliException e) {
35281       {
35282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35283       };
35284     } catch (...) {
35285       {
35286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35287       };
35288     }
35289   }
35290
35291 }
35292
35293
35294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35295   unsigned int jresult ;
35296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35297   bool result;
35298
35299   arg1 = (Dali::Actor *)jarg1;
35300   {
35301     try {
35302       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35303     } catch (std::out_of_range& e) {
35304       {
35305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35306       };
35307     } catch (std::exception& e) {
35308       {
35309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (Dali::DaliException e) {
35312       {
35313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35318       };
35319     }
35320   }
35321
35322   jresult = result;
35323   return jresult;
35324 }
35325
35326
35327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35328   void * jresult ;
35329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35330   Dali::Quaternion result;
35331
35332   arg1 = (Dali::Actor *)jarg1;
35333   {
35334     try {
35335       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35336     } catch (std::out_of_range& e) {
35337       {
35338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35339       };
35340     } catch (std::exception& e) {
35341       {
35342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35343       };
35344     } catch (Dali::DaliException e) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35347       };
35348     } catch (...) {
35349       {
35350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35351       };
35352     }
35353   }
35354
35355   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35356   return jresult;
35357 }
35358
35359
35360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35362   float arg2 ;
35363
35364   arg1 = (Dali::Actor *)jarg1;
35365   arg2 = (float)jarg2;
35366   {
35367     try {
35368       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35369     } catch (std::out_of_range& e) {
35370       {
35371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35372       };
35373     } catch (std::exception& e) {
35374       {
35375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35376       };
35377     } catch (Dali::DaliException e) {
35378       {
35379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35380       };
35381     } catch (...) {
35382       {
35383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35384       };
35385     }
35386   }
35387
35388 }
35389
35390
35391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   float arg2 ;
35394   float arg3 ;
35395   float arg4 ;
35396
35397   arg1 = (Dali::Actor *)jarg1;
35398   arg2 = (float)jarg2;
35399   arg3 = (float)jarg3;
35400   arg4 = (float)jarg4;
35401   {
35402     try {
35403       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35404     } catch (std::out_of_range& e) {
35405       {
35406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35407       };
35408     } catch (std::exception& e) {
35409       {
35410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35411       };
35412     } catch (Dali::DaliException e) {
35413       {
35414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35415       };
35416     } catch (...) {
35417       {
35418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35419       };
35420     }
35421   }
35422
35423 }
35424
35425
35426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35428   Dali::Vector3 *arg2 = 0 ;
35429
35430   arg1 = (Dali::Actor *)jarg1;
35431   arg2 = (Dali::Vector3 *)jarg2;
35432   if (!arg2) {
35433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35434     return ;
35435   }
35436   {
35437     try {
35438       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35439     } catch (std::out_of_range& e) {
35440       {
35441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35442       };
35443     } catch (std::exception& e) {
35444       {
35445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35446       };
35447     } catch (Dali::DaliException e) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35450       };
35451     } catch (...) {
35452       {
35453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35454       };
35455     }
35456   }
35457
35458 }
35459
35460
35461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35463   Dali::Vector3 *arg2 = 0 ;
35464
35465   arg1 = (Dali::Actor *)jarg1;
35466   arg2 = (Dali::Vector3 *)jarg2;
35467   if (!arg2) {
35468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35469     return ;
35470   }
35471   {
35472     try {
35473       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35474     } catch (std::out_of_range& e) {
35475       {
35476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35477       };
35478     } catch (std::exception& e) {
35479       {
35480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35481       };
35482     } catch (Dali::DaliException e) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35485       };
35486     } catch (...) {
35487       {
35488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35489       };
35490     }
35491   }
35492
35493 }
35494
35495
35496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35497   void * jresult ;
35498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35499   Dali::Vector3 result;
35500
35501   arg1 = (Dali::Actor *)jarg1;
35502   {
35503     try {
35504       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35505     } catch (std::out_of_range& e) {
35506       {
35507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35508       };
35509     } catch (std::exception& e) {
35510       {
35511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35512       };
35513     } catch (Dali::DaliException e) {
35514       {
35515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35516       };
35517     } catch (...) {
35518       {
35519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35520       };
35521     }
35522   }
35523
35524   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35525   return jresult;
35526 }
35527
35528
35529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35530   void * jresult ;
35531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35532   Dali::Vector3 result;
35533
35534   arg1 = (Dali::Actor *)jarg1;
35535   {
35536     try {
35537       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35538     } catch (std::out_of_range& e) {
35539       {
35540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (std::exception& e) {
35543       {
35544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35545       };
35546     } catch (Dali::DaliException e) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35549       };
35550     } catch (...) {
35551       {
35552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35553       };
35554     }
35555   }
35556
35557   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35564   bool arg2 ;
35565
35566   arg1 = (Dali::Actor *)jarg1;
35567   arg2 = jarg2 ? true : false;
35568   {
35569     try {
35570       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35571     } catch (std::out_of_range& e) {
35572       {
35573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35574       };
35575     } catch (std::exception& e) {
35576       {
35577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35578       };
35579     } catch (Dali::DaliException e) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35582       };
35583     } catch (...) {
35584       {
35585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35586       };
35587     }
35588   }
35589
35590 }
35591
35592
35593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35594   unsigned int jresult ;
35595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35596   bool result;
35597
35598   arg1 = (Dali::Actor *)jarg1;
35599   {
35600     try {
35601       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35602     } catch (std::out_of_range& e) {
35603       {
35604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35605       };
35606     } catch (std::exception& e) {
35607       {
35608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35609       };
35610     } catch (Dali::DaliException e) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35613       };
35614     } catch (...) {
35615       {
35616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35617       };
35618     }
35619   }
35620
35621   jresult = result;
35622   return jresult;
35623 }
35624
35625
35626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35627   void * jresult ;
35628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35629   Dali::Matrix result;
35630
35631   arg1 = (Dali::Actor *)jarg1;
35632   {
35633     try {
35634       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35635     } catch (std::out_of_range& e) {
35636       {
35637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (std::exception& e) {
35640       {
35641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35642       };
35643     } catch (Dali::DaliException e) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35646       };
35647     } catch (...) {
35648       {
35649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35650       };
35651     }
35652   }
35653
35654   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35655   return jresult;
35656 }
35657
35658
35659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35661   bool arg2 ;
35662
35663   arg1 = (Dali::Actor *)jarg1;
35664   arg2 = jarg2 ? true : false;
35665   {
35666     try {
35667       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35668     } catch (std::out_of_range& e) {
35669       {
35670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35671       };
35672     } catch (std::exception& e) {
35673       {
35674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35675       };
35676     } catch (Dali::DaliException e) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35679       };
35680     } catch (...) {
35681       {
35682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35683       };
35684     }
35685   }
35686
35687 }
35688
35689
35690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35691   unsigned int jresult ;
35692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35693   bool result;
35694
35695   arg1 = (Dali::Actor *)jarg1;
35696   {
35697     try {
35698       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35699     } catch (std::out_of_range& e) {
35700       {
35701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (std::exception& e) {
35704       {
35705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35706       };
35707     } catch (Dali::DaliException e) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35710       };
35711     } catch (...) {
35712       {
35713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35714       };
35715     }
35716   }
35717
35718   jresult = result;
35719   return jresult;
35720 }
35721
35722
35723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35725   float arg2 ;
35726
35727   arg1 = (Dali::Actor *)jarg1;
35728   arg2 = (float)jarg2;
35729   {
35730     try {
35731       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35732     } catch (std::out_of_range& e) {
35733       {
35734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (std::exception& e) {
35737       {
35738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35739       };
35740     } catch (Dali::DaliException e) {
35741       {
35742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35743       };
35744     } catch (...) {
35745       {
35746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35747       };
35748     }
35749   }
35750
35751 }
35752
35753
35754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35755   float jresult ;
35756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35757   float result;
35758
35759   arg1 = (Dali::Actor *)jarg1;
35760   {
35761     try {
35762       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35763     } catch (std::out_of_range& e) {
35764       {
35765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35766       };
35767     } catch (std::exception& e) {
35768       {
35769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35770       };
35771     } catch (Dali::DaliException e) {
35772       {
35773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35774       };
35775     } catch (...) {
35776       {
35777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35778       };
35779     }
35780   }
35781
35782   jresult = result;
35783   return jresult;
35784 }
35785
35786
35787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35789   Dali::Vector4 *arg2 = 0 ;
35790
35791   arg1 = (Dali::Actor *)jarg1;
35792   arg2 = (Dali::Vector4 *)jarg2;
35793   if (!arg2) {
35794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35795     return ;
35796   }
35797   {
35798     try {
35799       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35800     } catch (std::out_of_range& e) {
35801       {
35802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (std::exception& e) {
35805       {
35806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35807       };
35808     } catch (Dali::DaliException e) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35815       };
35816     }
35817   }
35818
35819 }
35820
35821
35822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35823   void * jresult ;
35824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35825   Dali::Vector4 result;
35826
35827   arg1 = (Dali::Actor *)jarg1;
35828   {
35829     try {
35830       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35831     } catch (std::out_of_range& e) {
35832       {
35833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (std::exception& e) {
35836       {
35837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35838       };
35839     } catch (Dali::DaliException e) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35842       };
35843     } catch (...) {
35844       {
35845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35846       };
35847     }
35848   }
35849
35850   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35851   return jresult;
35852 }
35853
35854
35855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35857   Dali::ColorMode arg2 ;
35858
35859   arg1 = (Dali::Actor *)jarg1;
35860   arg2 = (Dali::ColorMode)jarg2;
35861   {
35862     try {
35863       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35864     } catch (std::out_of_range& e) {
35865       {
35866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35867       };
35868     } catch (std::exception& e) {
35869       {
35870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35871       };
35872     } catch (Dali::DaliException e) {
35873       {
35874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35875       };
35876     } catch (...) {
35877       {
35878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35879       };
35880     }
35881   }
35882
35883 }
35884
35885
35886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35887   int jresult ;
35888   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35889   Dali::ColorMode result;
35890
35891   arg1 = (Dali::Actor *)jarg1;
35892   {
35893     try {
35894       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35895     } catch (std::out_of_range& e) {
35896       {
35897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35898       };
35899     } catch (std::exception& e) {
35900       {
35901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35902       };
35903     } catch (Dali::DaliException e) {
35904       {
35905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35906       };
35907     } catch (...) {
35908       {
35909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35910       };
35911     }
35912   }
35913
35914   jresult = (int)result;
35915   return jresult;
35916 }
35917
35918
35919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35920   void * jresult ;
35921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35922   Dali::Vector4 result;
35923
35924   arg1 = (Dali::Actor *)jarg1;
35925   {
35926     try {
35927       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35928     } catch (std::out_of_range& e) {
35929       {
35930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (std::exception& e) {
35933       {
35934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (Dali::DaliException e) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35939       };
35940     } catch (...) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35943       };
35944     }
35945   }
35946
35947   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35948   return jresult;
35949 }
35950
35951
35952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35954   Dali::DrawMode::Type arg2 ;
35955
35956   arg1 = (Dali::Actor *)jarg1;
35957   arg2 = (Dali::DrawMode::Type)jarg2;
35958   {
35959     try {
35960       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35961     } catch (std::out_of_range& e) {
35962       {
35963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35964       };
35965     } catch (std::exception& e) {
35966       {
35967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35968       };
35969     } catch (Dali::DaliException e) {
35970       {
35971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35972       };
35973     } catch (...) {
35974       {
35975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35976       };
35977     }
35978   }
35979
35980 }
35981
35982
35983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35984   int jresult ;
35985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35986   Dali::DrawMode::Type result;
35987
35988   arg1 = (Dali::Actor *)jarg1;
35989   {
35990     try {
35991       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35992     } catch (std::out_of_range& e) {
35993       {
35994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35995       };
35996     } catch (std::exception& e) {
35997       {
35998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35999       };
36000     } catch (Dali::DaliException e) {
36001       {
36002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36003       };
36004     } catch (...) {
36005       {
36006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36007       };
36008     }
36009   }
36010
36011   jresult = (int)result;
36012   return jresult;
36013 }
36014
36015
36016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36018   bool arg2 ;
36019
36020   arg1 = (Dali::Actor *)jarg1;
36021   arg2 = jarg2 ? true : false;
36022   {
36023     try {
36024       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36025     } catch (std::out_of_range& e) {
36026       {
36027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36028       };
36029     } catch (std::exception& e) {
36030       {
36031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36032       };
36033     } catch (Dali::DaliException e) {
36034       {
36035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36036       };
36037     } catch (...) {
36038       {
36039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36040       };
36041     }
36042   }
36043
36044 }
36045
36046
36047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36048   unsigned int jresult ;
36049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36050   bool result;
36051
36052   arg1 = (Dali::Actor *)jarg1;
36053   {
36054     try {
36055       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36056     } catch (std::out_of_range& e) {
36057       {
36058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36059       };
36060     } catch (std::exception& e) {
36061       {
36062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36063       };
36064     } catch (Dali::DaliException e) {
36065       {
36066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36067       };
36068     } catch (...) {
36069       {
36070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36071       };
36072     }
36073   }
36074
36075   jresult = result;
36076   return jresult;
36077 }
36078
36079
36080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36081   unsigned int jresult ;
36082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36083   float *arg2 = 0 ;
36084   float *arg3 = 0 ;
36085   float arg4 ;
36086   float arg5 ;
36087   bool result;
36088
36089   arg1 = (Dali::Actor *)jarg1;
36090   arg2 = (float *)jarg2;
36091   arg3 = (float *)jarg3;
36092   arg4 = (float)jarg4;
36093   arg5 = (float)jarg5;
36094   {
36095     try {
36096       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36097     } catch (std::out_of_range& e) {
36098       {
36099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36100       };
36101     } catch (std::exception& e) {
36102       {
36103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36104       };
36105     } catch (Dali::DaliException e) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36108       };
36109     } catch (...) {
36110       {
36111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36112       };
36113     }
36114   }
36115
36116   jresult = result;
36117   return jresult;
36118 }
36119
36120
36121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36123   bool arg2 ;
36124
36125   arg1 = (Dali::Actor *)jarg1;
36126   arg2 = jarg2 ? true : false;
36127   {
36128     try {
36129       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36130     } catch (std::out_of_range& e) {
36131       {
36132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36133       };
36134     } catch (std::exception& e) {
36135       {
36136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36137       };
36138     } catch (Dali::DaliException e) {
36139       {
36140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36141       };
36142     } catch (...) {
36143       {
36144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36145       };
36146     }
36147   }
36148
36149 }
36150
36151
36152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36153   unsigned int jresult ;
36154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36155   bool result;
36156
36157   arg1 = (Dali::Actor *)jarg1;
36158   {
36159     try {
36160       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36161     } catch (std::out_of_range& e) {
36162       {
36163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36164       };
36165     } catch (std::exception& e) {
36166       {
36167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36168       };
36169     } catch (Dali::DaliException e) {
36170       {
36171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36172       };
36173     } catch (...) {
36174       {
36175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36176       };
36177     }
36178   }
36179
36180   jresult = result;
36181   return jresult;
36182 }
36183
36184
36185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36187   bool arg2 ;
36188
36189   arg1 = (Dali::Actor *)jarg1;
36190   arg2 = jarg2 ? true : false;
36191   {
36192     try {
36193       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36194     } catch (std::out_of_range& e) {
36195       {
36196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36197       };
36198     } catch (std::exception& e) {
36199       {
36200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36201       };
36202     } catch (Dali::DaliException e) {
36203       {
36204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36205       };
36206     } catch (...) {
36207       {
36208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36209       };
36210     }
36211   }
36212
36213 }
36214
36215
36216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36217   unsigned int jresult ;
36218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36219   bool result;
36220
36221   arg1 = (Dali::Actor *)jarg1;
36222   {
36223     try {
36224       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36225     } catch (std::out_of_range& e) {
36226       {
36227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36228       };
36229     } catch (std::exception& e) {
36230       {
36231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (Dali::DaliException e) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36236       };
36237     } catch (...) {
36238       {
36239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36240       };
36241     }
36242   }
36243
36244   jresult = result;
36245   return jresult;
36246 }
36247
36248
36249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36251   Dali::ResizePolicy::Type arg2 ;
36252   Dali::Dimension::Type arg3 ;
36253
36254   arg1 = (Dali::Actor *)jarg1;
36255   arg2 = (Dali::ResizePolicy::Type)jarg2;
36256   arg3 = (Dali::Dimension::Type)jarg3;
36257   {
36258     try {
36259       (arg1)->SetResizePolicy(arg2,arg3);
36260     } catch (std::out_of_range& e) {
36261       {
36262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36263       };
36264     } catch (std::exception& e) {
36265       {
36266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36267       };
36268     } catch (Dali::DaliException e) {
36269       {
36270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36271       };
36272     } catch (...) {
36273       {
36274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36275       };
36276     }
36277   }
36278
36279 }
36280
36281
36282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36283   int jresult ;
36284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36285   Dali::Dimension::Type arg2 ;
36286   Dali::ResizePolicy::Type result;
36287
36288   arg1 = (Dali::Actor *)jarg1;
36289   arg2 = (Dali::Dimension::Type)jarg2;
36290   {
36291     try {
36292       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36293     } catch (std::out_of_range& e) {
36294       {
36295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36296       };
36297     } catch (std::exception& e) {
36298       {
36299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36300       };
36301     } catch (Dali::DaliException e) {
36302       {
36303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36304       };
36305     } catch (...) {
36306       {
36307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36308       };
36309     }
36310   }
36311
36312   jresult = (int)result;
36313   return jresult;
36314 }
36315
36316
36317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36319   Dali::SizeScalePolicy::Type arg2 ;
36320
36321   arg1 = (Dali::Actor *)jarg1;
36322   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36323   {
36324     try {
36325       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36326     } catch (std::out_of_range& e) {
36327       {
36328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (std::exception& e) {
36331       {
36332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36333       };
36334     } catch (Dali::DaliException e) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36337       };
36338     } catch (...) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36341       };
36342     }
36343   }
36344
36345 }
36346
36347
36348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36349   int jresult ;
36350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36351   Dali::SizeScalePolicy::Type result;
36352
36353   arg1 = (Dali::Actor *)jarg1;
36354   {
36355     try {
36356       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (Dali::DaliException e) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36368       };
36369     } catch (...) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36372       };
36373     }
36374   }
36375
36376   jresult = (int)result;
36377   return jresult;
36378 }
36379
36380
36381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36383   Dali::Vector3 *arg2 = 0 ;
36384
36385   arg1 = (Dali::Actor *)jarg1;
36386   arg2 = (Dali::Vector3 *)jarg2;
36387   if (!arg2) {
36388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36389     return ;
36390   }
36391   {
36392     try {
36393       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36394     } catch (std::out_of_range& e) {
36395       {
36396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36397       };
36398     } catch (std::exception& e) {
36399       {
36400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36401       };
36402     } catch (Dali::DaliException e) {
36403       {
36404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36405       };
36406     } catch (...) {
36407       {
36408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36409       };
36410     }
36411   }
36412
36413 }
36414
36415
36416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36417   void * jresult ;
36418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36419   Dali::Vector3 result;
36420
36421   arg1 = (Dali::Actor *)jarg1;
36422   {
36423     try {
36424       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36425     } catch (std::out_of_range& e) {
36426       {
36427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (std::exception& e) {
36430       {
36431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36432       };
36433     } catch (Dali::DaliException e) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36436       };
36437     } catch (...) {
36438       {
36439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36440       };
36441     }
36442   }
36443
36444   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36445   return jresult;
36446 }
36447
36448
36449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36450   float jresult ;
36451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36452   float arg2 ;
36453   float result;
36454
36455   arg1 = (Dali::Actor *)jarg1;
36456   arg2 = (float)jarg2;
36457   {
36458     try {
36459       result = (float)(arg1)->GetHeightForWidth(arg2);
36460     } catch (std::out_of_range& e) {
36461       {
36462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36463       };
36464     } catch (std::exception& e) {
36465       {
36466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36467       };
36468     } catch (Dali::DaliException e) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36471       };
36472     } catch (...) {
36473       {
36474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36475       };
36476     }
36477   }
36478
36479   jresult = result;
36480   return jresult;
36481 }
36482
36483
36484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36485   float jresult ;
36486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36487   float arg2 ;
36488   float result;
36489
36490   arg1 = (Dali::Actor *)jarg1;
36491   arg2 = (float)jarg2;
36492   {
36493     try {
36494       result = (float)(arg1)->GetWidthForHeight(arg2);
36495     } catch (std::out_of_range& e) {
36496       {
36497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36498       };
36499     } catch (std::exception& e) {
36500       {
36501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36502       };
36503     } catch (Dali::DaliException e) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36506       };
36507     } catch (...) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36510       };
36511     }
36512   }
36513
36514   jresult = result;
36515   return jresult;
36516 }
36517
36518
36519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36520   float jresult ;
36521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36522   Dali::Dimension::Type arg2 ;
36523   float result;
36524
36525   arg1 = (Dali::Actor *)jarg1;
36526   arg2 = (Dali::Dimension::Type)jarg2;
36527   {
36528     try {
36529       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36530     } catch (std::out_of_range& e) {
36531       {
36532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36533       };
36534     } catch (std::exception& e) {
36535       {
36536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36537       };
36538     } catch (Dali::DaliException e) {
36539       {
36540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36541       };
36542     } catch (...) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36545       };
36546     }
36547   }
36548
36549   jresult = result;
36550   return jresult;
36551 }
36552
36553
36554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   Dali::Padding *arg2 = 0 ;
36557
36558   arg1 = (Dali::Actor *)jarg1;
36559   arg2 = (Dali::Padding *)jarg2;
36560   if (!arg2) {
36561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36562     return ;
36563   }
36564   {
36565     try {
36566       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36567     } catch (std::out_of_range& e) {
36568       {
36569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36570       };
36571     } catch (std::exception& e) {
36572       {
36573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36574       };
36575     } catch (Dali::DaliException e) {
36576       {
36577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36578       };
36579     } catch (...) {
36580       {
36581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36582       };
36583     }
36584   }
36585
36586 }
36587
36588
36589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36591   Dali::Padding *arg2 = 0 ;
36592
36593   arg1 = (Dali::Actor *)jarg1;
36594   arg2 = (Dali::Padding *)jarg2;
36595   if (!arg2) {
36596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36597     return ;
36598   }
36599   {
36600     try {
36601       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36602     } catch (std::out_of_range& e) {
36603       {
36604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (std::exception& e) {
36607       {
36608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36609       };
36610     } catch (Dali::DaliException e) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36613       };
36614     } catch (...) {
36615       {
36616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36617       };
36618     }
36619   }
36620
36621 }
36622
36623
36624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36626   Dali::Vector2 *arg2 = 0 ;
36627
36628   arg1 = (Dali::Actor *)jarg1;
36629   arg2 = (Dali::Vector2 *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36632     return ;
36633   }
36634   {
36635     try {
36636       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36644       };
36645     } catch (Dali::DaliException e) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36648       };
36649     } catch (...) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36652       };
36653     }
36654   }
36655
36656 }
36657
36658
36659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36660   void * jresult ;
36661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36662   Dali::Vector2 result;
36663
36664   arg1 = (Dali::Actor *)jarg1;
36665   {
36666     try {
36667       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36668     } catch (std::out_of_range& e) {
36669       {
36670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (std::exception& e) {
36673       {
36674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (Dali::DaliException e) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36683       };
36684     }
36685   }
36686
36687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36694   Dali::Vector2 *arg2 = 0 ;
36695
36696   arg1 = (Dali::Actor *)jarg1;
36697   arg2 = (Dali::Vector2 *)jarg2;
36698   if (!arg2) {
36699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36700     return ;
36701   }
36702   {
36703     try {
36704       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36705     } catch (std::out_of_range& e) {
36706       {
36707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36708       };
36709     } catch (std::exception& e) {
36710       {
36711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36712       };
36713     } catch (Dali::DaliException e) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36716       };
36717     } catch (...) {
36718       {
36719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36720       };
36721     }
36722   }
36723
36724 }
36725
36726
36727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36728   void * jresult ;
36729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36730   Dali::Vector2 result;
36731
36732   arg1 = (Dali::Actor *)jarg1;
36733   {
36734     try {
36735       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (Dali::DaliException e) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36747       };
36748     } catch (...) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36751       };
36752     }
36753   }
36754
36755   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36756   return jresult;
36757 }
36758
36759
36760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36761   int jresult ;
36762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36763   int result;
36764
36765   arg1 = (Dali::Actor *)jarg1;
36766   {
36767     try {
36768       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36769       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36770     } catch (std::out_of_range& e) {
36771       {
36772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36773       };
36774     } catch (std::exception& e) {
36775       {
36776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36777       };
36778     } catch (Dali::DaliException e) {
36779       {
36780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36781       };
36782     } catch (...) {
36783       {
36784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36785       };
36786     }
36787   }
36788
36789   jresult = result;
36790   return jresult;
36791 }
36792
36793
36794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36795   unsigned int jresult ;
36796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36797   Dali::Renderer *arg2 = 0 ;
36798   unsigned int result;
36799
36800   arg1 = (Dali::Actor *)jarg1;
36801   arg2 = (Dali::Renderer *)jarg2;
36802   if (!arg2) {
36803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36804     return 0;
36805   }
36806   {
36807     try {
36808       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36809     } catch (std::out_of_range& e) {
36810       {
36811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36812       };
36813     } catch (std::exception& e) {
36814       {
36815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36816       };
36817     } catch (Dali::DaliException e) {
36818       {
36819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36820       };
36821     } catch (...) {
36822       {
36823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36824       };
36825     }
36826   }
36827
36828   jresult = result;
36829   return jresult;
36830 }
36831
36832
36833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36834   unsigned int jresult ;
36835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36836   unsigned int result;
36837
36838   arg1 = (Dali::Actor *)jarg1;
36839   {
36840     try {
36841       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36842     } catch (std::out_of_range& e) {
36843       {
36844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36845       };
36846     } catch (std::exception& e) {
36847       {
36848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36849       };
36850     } catch (Dali::DaliException e) {
36851       {
36852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36853       };
36854     } catch (...) {
36855       {
36856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36857       };
36858     }
36859   }
36860
36861   jresult = result;
36862   return jresult;
36863 }
36864
36865
36866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36867   void * jresult ;
36868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36869   unsigned int arg2 ;
36870   Dali::Renderer result;
36871
36872   arg1 = (Dali::Actor *)jarg1;
36873   arg2 = (unsigned int)jarg2;
36874   {
36875     try {
36876       result = (arg1)->GetRendererAt(arg2);
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (Dali::DaliException e) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36892       };
36893     }
36894   }
36895
36896   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36903   Dali::Renderer *arg2 = 0 ;
36904
36905   arg1 = (Dali::Actor *)jarg1;
36906   arg2 = (Dali::Renderer *)jarg2;
36907   if (!arg2) {
36908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36909     return ;
36910   }
36911   {
36912     try {
36913       (arg1)->RemoveRenderer(*arg2);
36914     } catch (std::out_of_range& e) {
36915       {
36916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36917       };
36918     } catch (std::exception& e) {
36919       {
36920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36921       };
36922     } catch (Dali::DaliException e) {
36923       {
36924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36925       };
36926     } catch (...) {
36927       {
36928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36929       };
36930     }
36931   }
36932
36933 }
36934
36935
36936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36938   unsigned int arg2 ;
36939
36940   arg1 = (Dali::Actor *)jarg1;
36941   arg2 = (unsigned int)jarg2;
36942   {
36943     try {
36944       (arg1)->RemoveRenderer(arg2);
36945     } catch (std::out_of_range& e) {
36946       {
36947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36948       };
36949     } catch (std::exception& e) {
36950       {
36951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36952       };
36953     } catch (Dali::DaliException e) {
36954       {
36955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36956       };
36957     } catch (...) {
36958       {
36959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36960       };
36961     }
36962   }
36963
36964 }
36965
36966
36967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36968   void * jresult ;
36969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36970   Dali::Actor::TouchEventSignalType *result = 0 ;
36971
36972   arg1 = (Dali::Actor *)jarg1;
36973   {
36974     try {
36975       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
36976     } catch (std::out_of_range& e) {
36977       {
36978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (std::exception& e) {
36981       {
36982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (Dali::DaliException e) {
36985       {
36986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36987       };
36988     } catch (...) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36991       };
36992     }
36993   }
36994
36995   jresult = (void *)result;
36996   return jresult;
36997 }
36998
36999
37000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37001   void * jresult ;
37002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37003   Dali::Actor::HoverSignalType *result = 0 ;
37004
37005   arg1 = (Dali::Actor *)jarg1;
37006   {
37007     try {
37008       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37009     } catch (std::out_of_range& e) {
37010       {
37011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37012       };
37013     } catch (std::exception& e) {
37014       {
37015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37016       };
37017     } catch (Dali::DaliException e) {
37018       {
37019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37020       };
37021     } catch (...) {
37022       {
37023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37024       };
37025     }
37026   }
37027
37028   jresult = (void *)result;
37029   return jresult;
37030 }
37031
37032
37033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37034   void * jresult ;
37035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37036   Dali::Actor::WheelEventSignalType *result = 0 ;
37037
37038   arg1 = (Dali::Actor *)jarg1;
37039   {
37040     try {
37041       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37042     } catch (std::out_of_range& e) {
37043       {
37044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37045       };
37046     } catch (std::exception& e) {
37047       {
37048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37049       };
37050     } catch (Dali::DaliException e) {
37051       {
37052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37053       };
37054     } catch (...) {
37055       {
37056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37057       };
37058     }
37059   }
37060
37061   jresult = (void *)result;
37062   return jresult;
37063 }
37064
37065
37066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
37067   void * jresult ;
37068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37069   Dali::Actor::OnSceneSignalType *result = 0 ;
37070
37071   arg1 = (Dali::Actor *)jarg1;
37072   {
37073     try {
37074       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
37075     } catch (std::out_of_range& e) {
37076       {
37077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37078       };
37079     } catch (std::exception& e) {
37080       {
37081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37082       };
37083     } catch (Dali::DaliException e) {
37084       {
37085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37086       };
37087     } catch (...) {
37088       {
37089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37090       };
37091     }
37092   }
37093
37094   jresult = (void *)result;
37095   return jresult;
37096 }
37097
37098
37099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
37100   void * jresult ;
37101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37102   Dali::Actor::OffSceneSignalType *result = 0 ;
37103
37104   arg1 = (Dali::Actor *)jarg1;
37105   {
37106     try {
37107       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
37108     } catch (std::out_of_range& e) {
37109       {
37110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37111       };
37112     } catch (std::exception& e) {
37113       {
37114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37115       };
37116     } catch (Dali::DaliException e) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37119       };
37120     } catch (...) {
37121       {
37122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37123       };
37124     }
37125   }
37126
37127   jresult = (void *)result;
37128   return jresult;
37129 }
37130
37131
37132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37133   void * jresult ;
37134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37135   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37136
37137   arg1 = (Dali::Actor *)jarg1;
37138   {
37139     try {
37140       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37148       };
37149     } catch (Dali::DaliException e) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37152       };
37153     } catch (...) {
37154       {
37155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37156       };
37157     }
37158   }
37159
37160   jresult = (void *)result;
37161   return jresult;
37162 }
37163
37164
37165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37166   Dali::Actor *arg1 = 0 ;
37167
37168   arg1 = (Dali::Actor *)jarg1;
37169   if (!arg1) {
37170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37171     return ;
37172   }
37173   {
37174     try {
37175       Dali::UnparentAndReset(*arg1);
37176     } catch (std::out_of_range& e) {
37177       {
37178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37179       };
37180     } catch (std::exception& e) {
37181       {
37182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37183       };
37184     } catch (Dali::DaliException e) {
37185       {
37186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37187       };
37188     } catch (...) {
37189       {
37190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37191       };
37192     }
37193   }
37194
37195 }
37196
37197
37198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37199   int jresult ;
37200   int result;
37201
37202   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37203   jresult = (int)result;
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37209   int jresult ;
37210   int result;
37211
37212   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37213   jresult = (int)result;
37214   return jresult;
37215 }
37216
37217
37218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37219   int jresult ;
37220   int result;
37221
37222   result = (int)Dali::Layer::Property::BEHAVIOR;
37223   jresult = (int)result;
37224   return jresult;
37225 }
37226
37227
37228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37229   void * jresult ;
37230   Dali::Layer::Property *result = 0 ;
37231
37232   {
37233     try {
37234       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37235     } catch (std::out_of_range& e) {
37236       {
37237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (std::exception& e) {
37240       {
37241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37242       };
37243     } catch (Dali::DaliException e) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37246       };
37247     } catch (...) {
37248       {
37249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37250       };
37251     }
37252   }
37253
37254   jresult = (void *)result;
37255   return jresult;
37256 }
37257
37258
37259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37260   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37261
37262   arg1 = (Dali::Layer::Property *)jarg1;
37263   {
37264     try {
37265       delete arg1;
37266     } catch (std::out_of_range& e) {
37267       {
37268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37269       };
37270     } catch (std::exception& e) {
37271       {
37272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37273       };
37274     } catch (Dali::DaliException e) {
37275       {
37276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37277       };
37278     } catch (...) {
37279       {
37280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37281       };
37282     }
37283   }
37284
37285 }
37286
37287
37288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37289   void * jresult ;
37290   Dali::Layer *result = 0 ;
37291
37292   {
37293     try {
37294       result = (Dali::Layer *)new Dali::Layer();
37295     } catch (std::out_of_range& e) {
37296       {
37297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37298       };
37299     } catch (std::exception& e) {
37300       {
37301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37302       };
37303     } catch (Dali::DaliException e) {
37304       {
37305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37306       };
37307     } catch (...) {
37308       {
37309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37310       };
37311     }
37312   }
37313
37314   jresult = (void *)result;
37315   return jresult;
37316 }
37317
37318
37319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37320   void * jresult ;
37321   Dali::Layer result;
37322
37323   {
37324     try {
37325       result = Dali::Layer::New();
37326     } catch (std::out_of_range& e) {
37327       {
37328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37329       };
37330     } catch (std::exception& e) {
37331       {
37332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37333       };
37334     } catch (Dali::DaliException e) {
37335       {
37336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37337       };
37338     } catch (...) {
37339       {
37340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37341       };
37342     }
37343   }
37344
37345   jresult = new Dali::Layer((const Dali::Layer &)result);
37346   return jresult;
37347 }
37348
37349
37350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37351   void * jresult ;
37352   Dali::BaseHandle arg1 ;
37353   Dali::BaseHandle *argp1 ;
37354   Dali::Layer result;
37355
37356   argp1 = (Dali::BaseHandle *)jarg1;
37357   if (!argp1) {
37358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37359     return 0;
37360   }
37361   arg1 = *argp1;
37362   {
37363     try {
37364       result = Dali::Layer::DownCast(arg1);
37365     } catch (std::out_of_range& e) {
37366       {
37367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37368       };
37369     } catch (std::exception& e) {
37370       {
37371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37372       };
37373     } catch (Dali::DaliException e) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37376       };
37377     } catch (...) {
37378       {
37379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37380       };
37381     }
37382   }
37383
37384   jresult = new Dali::Layer((const Dali::Layer &)result);
37385   return jresult;
37386 }
37387
37388
37389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37390   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37391
37392   arg1 = (Dali::Layer *)jarg1;
37393   {
37394     try {
37395       delete arg1;
37396     } catch (std::out_of_range& e) {
37397       {
37398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37399       };
37400     } catch (std::exception& e) {
37401       {
37402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37403       };
37404     } catch (Dali::DaliException e) {
37405       {
37406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37407       };
37408     } catch (...) {
37409       {
37410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37411       };
37412     }
37413   }
37414
37415 }
37416
37417
37418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37419   void * jresult ;
37420   Dali::Layer *arg1 = 0 ;
37421   Dali::Layer *result = 0 ;
37422
37423   arg1 = (Dali::Layer *)jarg1;
37424   if (!arg1) {
37425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37426     return 0;
37427   }
37428   {
37429     try {
37430       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37431     } catch (std::out_of_range& e) {
37432       {
37433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37434       };
37435     } catch (std::exception& e) {
37436       {
37437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37438       };
37439     } catch (Dali::DaliException e) {
37440       {
37441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37442       };
37443     } catch (...) {
37444       {
37445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37446       };
37447     }
37448   }
37449
37450   jresult = (void *)result;
37451   return jresult;
37452 }
37453
37454
37455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37456   void * jresult ;
37457   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37458   Dali::Layer *arg2 = 0 ;
37459   Dali::Layer *result = 0 ;
37460
37461   arg1 = (Dali::Layer *)jarg1;
37462   arg2 = (Dali::Layer *)jarg2;
37463   if (!arg2) {
37464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37465     return 0;
37466   }
37467   {
37468     try {
37469       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37470     } catch (std::out_of_range& e) {
37471       {
37472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37473       };
37474     } catch (std::exception& e) {
37475       {
37476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37477       };
37478     } catch (Dali::DaliException e) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37481       };
37482     } catch (...) {
37483       {
37484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37485       };
37486     }
37487   }
37488
37489   jresult = (void *)result;
37490   return jresult;
37491 }
37492
37493
37494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37495   unsigned int jresult ;
37496   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37497   unsigned int result;
37498
37499   arg1 = (Dali::Layer *)jarg1;
37500   {
37501     try {
37502       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37503     } catch (std::out_of_range& e) {
37504       {
37505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37506       };
37507     } catch (std::exception& e) {
37508       {
37509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37510       };
37511     } catch (Dali::DaliException e) {
37512       {
37513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37514       };
37515     } catch (...) {
37516       {
37517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37518       };
37519     }
37520   }
37521
37522   jresult = result;
37523   return jresult;
37524 }
37525
37526
37527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37528   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37529
37530   arg1 = (Dali::Layer *)jarg1;
37531   {
37532     try {
37533       (arg1)->Raise();
37534     } catch (std::out_of_range& e) {
37535       {
37536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37537       };
37538     } catch (std::exception& e) {
37539       {
37540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37541       };
37542     } catch (Dali::DaliException e) {
37543       {
37544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37545       };
37546     } catch (...) {
37547       {
37548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37549       };
37550     }
37551   }
37552
37553 }
37554
37555
37556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37557   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37558
37559   arg1 = (Dali::Layer *)jarg1;
37560   {
37561     try {
37562       (arg1)->Lower();
37563     } catch (std::out_of_range& e) {
37564       {
37565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37566       };
37567     } catch (std::exception& e) {
37568       {
37569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37570       };
37571     } catch (Dali::DaliException e) {
37572       {
37573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37574       };
37575     } catch (...) {
37576       {
37577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37578       };
37579     }
37580   }
37581
37582 }
37583
37584
37585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37586   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37587   Dali::Layer arg2 ;
37588   Dali::Layer *argp2 ;
37589
37590   arg1 = (Dali::Layer *)jarg1;
37591   argp2 = (Dali::Layer *)jarg2;
37592   if (!argp2) {
37593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37594     return ;
37595   }
37596   arg2 = *argp2;
37597   {
37598     try {
37599       (arg1)->RaiseAbove(arg2);
37600     } catch (std::out_of_range& e) {
37601       {
37602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37603       };
37604     } catch (std::exception& e) {
37605       {
37606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37607       };
37608     } catch (Dali::DaliException e) {
37609       {
37610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37611       };
37612     } catch (...) {
37613       {
37614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37615       };
37616     }
37617   }
37618
37619 }
37620
37621
37622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37623   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37624   Dali::Layer arg2 ;
37625   Dali::Layer *argp2 ;
37626
37627   arg1 = (Dali::Layer *)jarg1;
37628   argp2 = (Dali::Layer *)jarg2;
37629   if (!argp2) {
37630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37631     return ;
37632   }
37633   arg2 = *argp2;
37634   {
37635     try {
37636       (arg1)->LowerBelow(arg2);
37637     } catch (std::out_of_range& e) {
37638       {
37639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37640       };
37641     } catch (std::exception& e) {
37642       {
37643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37644       };
37645     } catch (Dali::DaliException e) {
37646       {
37647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37648       };
37649     } catch (...) {
37650       {
37651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37652       };
37653     }
37654   }
37655
37656 }
37657
37658
37659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37660   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37661
37662   arg1 = (Dali::Layer *)jarg1;
37663   {
37664     try {
37665       (arg1)->RaiseToTop();
37666     } catch (std::out_of_range& e) {
37667       {
37668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37669       };
37670     } catch (std::exception& e) {
37671       {
37672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37673       };
37674     } catch (Dali::DaliException e) {
37675       {
37676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37677       };
37678     } catch (...) {
37679       {
37680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37681       };
37682     }
37683   }
37684
37685 }
37686
37687
37688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37689   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37690
37691   arg1 = (Dali::Layer *)jarg1;
37692   {
37693     try {
37694       (arg1)->LowerToBottom();
37695     } catch (std::out_of_range& e) {
37696       {
37697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (std::exception& e) {
37700       {
37701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37702       };
37703     } catch (Dali::DaliException e) {
37704       {
37705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37706       };
37707     } catch (...) {
37708       {
37709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37710       };
37711     }
37712   }
37713
37714 }
37715
37716
37717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37718   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37719   Dali::Layer arg2 ;
37720   Dali::Layer *argp2 ;
37721
37722   arg1 = (Dali::Layer *)jarg1;
37723   argp2 = (Dali::Layer *)jarg2;
37724   if (!argp2) {
37725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37726     return ;
37727   }
37728   arg2 = *argp2;
37729   {
37730     try {
37731       (arg1)->MoveAbove(arg2);
37732     } catch (std::out_of_range& e) {
37733       {
37734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37735       };
37736     } catch (std::exception& e) {
37737       {
37738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37739       };
37740     } catch (Dali::DaliException e) {
37741       {
37742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37743       };
37744     } catch (...) {
37745       {
37746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37747       };
37748     }
37749   }
37750
37751 }
37752
37753
37754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37755   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37756   Dali::Layer arg2 ;
37757   Dali::Layer *argp2 ;
37758
37759   arg1 = (Dali::Layer *)jarg1;
37760   argp2 = (Dali::Layer *)jarg2;
37761   if (!argp2) {
37762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37763     return ;
37764   }
37765   arg2 = *argp2;
37766   {
37767     try {
37768       (arg1)->MoveBelow(arg2);
37769     } catch (std::out_of_range& e) {
37770       {
37771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37772       };
37773     } catch (std::exception& e) {
37774       {
37775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37776       };
37777     } catch (Dali::DaliException e) {
37778       {
37779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37780       };
37781     } catch (...) {
37782       {
37783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37784       };
37785     }
37786   }
37787
37788 }
37789
37790
37791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37792   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37793   Dali::Layer::Behavior arg2 ;
37794
37795   arg1 = (Dali::Layer *)jarg1;
37796   arg2 = (Dali::Layer::Behavior)jarg2;
37797   {
37798     try {
37799       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37800     } catch (std::out_of_range& e) {
37801       {
37802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37803       };
37804     } catch (std::exception& e) {
37805       {
37806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37807       };
37808     } catch (Dali::DaliException e) {
37809       {
37810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37811       };
37812     } catch (...) {
37813       {
37814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37815       };
37816     }
37817   }
37818
37819 }
37820
37821
37822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37823   int jresult ;
37824   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37825   Dali::Layer::Behavior result;
37826
37827   arg1 = (Dali::Layer *)jarg1;
37828   {
37829     try {
37830       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37831     } catch (std::out_of_range& e) {
37832       {
37833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37834       };
37835     } catch (std::exception& e) {
37836       {
37837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37838       };
37839     } catch (Dali::DaliException e) {
37840       {
37841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37842       };
37843     } catch (...) {
37844       {
37845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37846       };
37847     }
37848   }
37849
37850   jresult = (int)result;
37851   return jresult;
37852 }
37853
37854
37855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37856   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37857   bool arg2 ;
37858
37859   arg1 = (Dali::Layer *)jarg1;
37860   arg2 = jarg2 ? true : false;
37861   {
37862     try {
37863       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37864     } catch (std::out_of_range& e) {
37865       {
37866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37867       };
37868     } catch (std::exception& e) {
37869       {
37870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37871       };
37872     } catch (Dali::DaliException e) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37875       };
37876     } catch (...) {
37877       {
37878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37879       };
37880     }
37881   }
37882
37883 }
37884
37885
37886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37887   unsigned int jresult ;
37888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37889   bool result;
37890
37891   arg1 = (Dali::Layer *)jarg1;
37892   {
37893     try {
37894       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37895     } catch (std::out_of_range& e) {
37896       {
37897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37898       };
37899     } catch (std::exception& e) {
37900       {
37901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37902       };
37903     } catch (Dali::DaliException e) {
37904       {
37905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37906       };
37907     } catch (...) {
37908       {
37909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37910       };
37911     }
37912   }
37913
37914   jresult = result;
37915   return jresult;
37916 }
37917
37918
37919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37920   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37921   int arg2 ;
37922   int arg3 ;
37923   int arg4 ;
37924   int arg5 ;
37925
37926   arg1 = (Dali::Layer *)jarg1;
37927   arg2 = (int)jarg2;
37928   arg3 = (int)jarg3;
37929   arg4 = (int)jarg4;
37930   arg5 = (int)jarg5;
37931   {
37932     try {
37933       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37934     } catch (std::out_of_range& e) {
37935       {
37936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37937       };
37938     } catch (std::exception& e) {
37939       {
37940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37941       };
37942     } catch (Dali::DaliException e) {
37943       {
37944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37945       };
37946     } catch (...) {
37947       {
37948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37949       };
37950     }
37951   }
37952
37953 }
37954
37955
37956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37957   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37958   Dali::ClippingBox arg2 ;
37959   Dali::ClippingBox *argp2 ;
37960
37961   arg1 = (Dali::Layer *)jarg1;
37962   argp2 = (Dali::ClippingBox *)jarg2;
37963   if (!argp2) {
37964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37965     return ;
37966   }
37967   arg2 = *argp2;
37968   {
37969     try {
37970       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37971     } catch (std::out_of_range& e) {
37972       {
37973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37974       };
37975     } catch (std::exception& e) {
37976       {
37977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37978       };
37979     } catch (Dali::DaliException e) {
37980       {
37981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37982       };
37983     } catch (...) {
37984       {
37985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37986       };
37987     }
37988   }
37989
37990 }
37991
37992
37993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37994   void * jresult ;
37995   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37996   Dali::ClippingBox result;
37997
37998   arg1 = (Dali::Layer *)jarg1;
37999   {
38000     try {
38001       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
38002     } catch (std::out_of_range& e) {
38003       {
38004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38005       };
38006     } catch (std::exception& e) {
38007       {
38008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38009       };
38010     } catch (Dali::DaliException e) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38013       };
38014     } catch (...) {
38015       {
38016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38017       };
38018     }
38019   }
38020
38021   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38022   return jresult;
38023 }
38024
38025
38026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38027   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38028   bool arg2 ;
38029
38030   arg1 = (Dali::Layer *)jarg1;
38031   arg2 = jarg2 ? true : false;
38032   {
38033     try {
38034       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
38035     } catch (std::out_of_range& e) {
38036       {
38037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38038       };
38039     } catch (std::exception& e) {
38040       {
38041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38042       };
38043     } catch (Dali::DaliException e) {
38044       {
38045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38046       };
38047     } catch (...) {
38048       {
38049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38050       };
38051     }
38052   }
38053
38054 }
38055
38056
38057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38058   unsigned int jresult ;
38059   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38060   bool result;
38061
38062   arg1 = (Dali::Layer *)jarg1;
38063   {
38064     try {
38065       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
38066     } catch (std::out_of_range& e) {
38067       {
38068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38069       };
38070     } catch (std::exception& e) {
38071       {
38072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38073       };
38074     } catch (Dali::DaliException e) {
38075       {
38076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38077       };
38078     } catch (...) {
38079       {
38080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38081       };
38082     }
38083   }
38084
38085   jresult = result;
38086   return jresult;
38087 }
38088
38089
38090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38091   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38092   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38093
38094   arg1 = (Dali::Layer *)jarg1;
38095   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38096   {
38097     try {
38098       (arg1)->SetSortFunction(arg2);
38099     } catch (std::out_of_range& e) {
38100       {
38101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38102       };
38103     } catch (std::exception& e) {
38104       {
38105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38106       };
38107     } catch (Dali::DaliException e) {
38108       {
38109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38110       };
38111     } catch (...) {
38112       {
38113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38114       };
38115     }
38116   }
38117
38118 }
38119
38120
38121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38122   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38123   bool arg2 ;
38124
38125   arg1 = (Dali::Layer *)jarg1;
38126   arg2 = jarg2 ? true : false;
38127   {
38128     try {
38129       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38130     } catch (std::out_of_range& e) {
38131       {
38132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (std::exception& e) {
38135       {
38136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38137       };
38138     } catch (Dali::DaliException e) {
38139       {
38140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38141       };
38142     } catch (...) {
38143       {
38144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38145       };
38146     }
38147   }
38148
38149 }
38150
38151
38152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38153   unsigned int jresult ;
38154   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38155   bool result;
38156
38157   arg1 = (Dali::Layer *)jarg1;
38158   {
38159     try {
38160       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38161     } catch (std::out_of_range& e) {
38162       {
38163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38164       };
38165     } catch (std::exception& e) {
38166       {
38167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38168       };
38169     } catch (Dali::DaliException e) {
38170       {
38171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38172       };
38173     } catch (...) {
38174       {
38175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38176       };
38177     }
38178   }
38179
38180   jresult = result;
38181   return jresult;
38182 }
38183
38184
38185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38186   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38187   bool arg2 ;
38188
38189   arg1 = (Dali::Layer *)jarg1;
38190   arg2 = jarg2 ? true : false;
38191   {
38192     try {
38193       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38194     } catch (std::out_of_range& e) {
38195       {
38196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38197       };
38198     } catch (std::exception& e) {
38199       {
38200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38201       };
38202     } catch (Dali::DaliException e) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38205       };
38206     } catch (...) {
38207       {
38208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38209       };
38210     }
38211   }
38212
38213 }
38214
38215
38216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38217   unsigned int jresult ;
38218   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38219   bool result;
38220
38221   arg1 = (Dali::Layer *)jarg1;
38222   {
38223     try {
38224       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38225     } catch (std::out_of_range& e) {
38226       {
38227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38228       };
38229     } catch (std::exception& e) {
38230       {
38231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38232       };
38233     } catch (Dali::DaliException e) {
38234       {
38235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38236       };
38237     } catch (...) {
38238       {
38239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38240       };
38241     }
38242   }
38243
38244   jresult = result;
38245   return jresult;
38246 }
38247
38248
38249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38250   void * jresult ;
38251   Dali::Stage result;
38252
38253   {
38254     try {
38255       result = Dali::Stage::GetCurrent();
38256     } catch (std::out_of_range& e) {
38257       {
38258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38259       };
38260     } catch (std::exception& e) {
38261       {
38262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38263       };
38264     } catch (Dali::DaliException e) {
38265       {
38266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38267       };
38268     } catch (...) {
38269       {
38270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38271       };
38272     }
38273   }
38274
38275   jresult = new Dali::Stage((const Dali::Stage &)result);
38276   return jresult;
38277 }
38278
38279
38280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38281   unsigned int jresult ;
38282   bool result;
38283
38284   {
38285     try {
38286       result = (bool)Dali::Stage::IsInstalled();
38287     } catch (std::out_of_range& e) {
38288       {
38289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38290       };
38291     } catch (std::exception& e) {
38292       {
38293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38294       };
38295     } catch (Dali::DaliException e) {
38296       {
38297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38298       };
38299     } catch (...) {
38300       {
38301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38302       };
38303     }
38304   }
38305
38306   jresult = result;
38307   return jresult;
38308 }
38309
38310
38311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38312   void * jresult ;
38313   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38314   Dali::Vector2 result;
38315
38316   arg1 = (Dali::Stage *)jarg1;
38317   {
38318     try {
38319       result = ((Dali::Stage const *)arg1)->GetDpi();
38320     } catch (std::out_of_range& e) {
38321       {
38322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38323       };
38324     } catch (std::exception& e) {
38325       {
38326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38327       };
38328     } catch (Dali::DaliException e) {
38329       {
38330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38331       };
38332     } catch (...) {
38333       {
38334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38335       };
38336     }
38337   }
38338
38339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38340   return jresult;
38341 }
38342
38343
38344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38345   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38346   float arg2 ;
38347
38348   arg1 = (Dali::Stage *)jarg1;
38349   arg2 = (float)jarg2;
38350   {
38351     try {
38352       (arg1)->KeepRendering(arg2);
38353     } catch (std::out_of_range& e) {
38354       {
38355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38356       };
38357     } catch (std::exception& e) {
38358       {
38359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38360       };
38361     } catch (Dali::DaliException e) {
38362       {
38363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38364       };
38365     } catch (...) {
38366       {
38367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38368       };
38369     }
38370   }
38371
38372 }
38373
38374
38375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38376   void * jresult ;
38377   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38378   Dali::Stage::KeyEventSignalType *result = 0 ;
38379
38380   arg1 = (Dali::Stage *)jarg1;
38381   {
38382     try {
38383       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38384     } catch (std::out_of_range& e) {
38385       {
38386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38387       };
38388     } catch (std::exception& e) {
38389       {
38390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38391       };
38392     } catch (Dali::DaliException e) {
38393       {
38394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38395       };
38396     } catch (...) {
38397       {
38398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38399       };
38400     }
38401   }
38402
38403   jresult = (void *)result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38409   void * jresult ;
38410   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38411   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38412
38413   arg1 = (Dali::Stage *)jarg1;
38414   {
38415     try {
38416       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (Dali::DaliException e) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38428       };
38429     } catch (...) {
38430       {
38431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38432       };
38433     }
38434   }
38435
38436   jresult = (void *)result;
38437   return jresult;
38438 }
38439
38440
38441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38442   void * jresult ;
38443   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38444   Dali::Stage::TouchSignalType *result = 0 ;
38445
38446   arg1 = (Dali::Stage *)jarg1;
38447   {
38448     try {
38449       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38450     } catch (std::out_of_range& e) {
38451       {
38452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38453       };
38454     } catch (std::exception& e) {
38455       {
38456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38457       };
38458     } catch (Dali::DaliException e) {
38459       {
38460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38461       };
38462     } catch (...) {
38463       {
38464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38465       };
38466     }
38467   }
38468
38469   jresult = (void *)result;
38470   return jresult;
38471 }
38472
38473
38474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38475   void * jresult ;
38476   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38477   Dali::Stage::WheelEventSignalType *result = 0 ;
38478
38479   arg1 = (Dali::Stage *)jarg1;
38480   {
38481     try {
38482       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38483     } catch (std::out_of_range& e) {
38484       {
38485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38486       };
38487     } catch (std::exception& e) {
38488       {
38489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38490       };
38491     } catch (Dali::DaliException e) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38494       };
38495     } catch (...) {
38496       {
38497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38498       };
38499     }
38500   }
38501
38502   jresult = (void *)result;
38503   return jresult;
38504 }
38505
38506
38507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38508   void * jresult ;
38509   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38510   Dali::Stage::ContextStatusSignal *result = 0 ;
38511
38512   arg1 = (Dali::Stage *)jarg1;
38513   {
38514     try {
38515       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38516     } catch (std::out_of_range& e) {
38517       {
38518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38519       };
38520     } catch (std::exception& e) {
38521       {
38522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (Dali::DaliException e) {
38525       {
38526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38527       };
38528     } catch (...) {
38529       {
38530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38531       };
38532     }
38533   }
38534
38535   jresult = (void *)result;
38536   return jresult;
38537 }
38538
38539
38540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38541   void * jresult ;
38542   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38543   Dali::Stage::ContextStatusSignal *result = 0 ;
38544
38545   arg1 = (Dali::Stage *)jarg1;
38546   {
38547     try {
38548       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38549     } catch (std::out_of_range& e) {
38550       {
38551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38552       };
38553     } catch (std::exception& e) {
38554       {
38555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38556       };
38557     } catch (Dali::DaliException e) {
38558       {
38559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38560       };
38561     } catch (...) {
38562       {
38563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38564       };
38565     }
38566   }
38567
38568   jresult = (void *)result;
38569   return jresult;
38570 }
38571
38572
38573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38574   void * jresult ;
38575   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38576   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38577
38578   arg1 = (Dali::Stage *)jarg1;
38579   {
38580     try {
38581       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38582     } catch (std::out_of_range& e) {
38583       {
38584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38585       };
38586     } catch (std::exception& e) {
38587       {
38588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38589       };
38590     } catch (Dali::DaliException e) {
38591       {
38592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38593       };
38594     } catch (...) {
38595       {
38596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38597       };
38598     }
38599   }
38600
38601   jresult = (void *)result;
38602   return jresult;
38603 }
38604
38605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38606   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38607   Dali::DevelStage::Rendering arg2 ;
38608
38609   arg1 = (Dali::Stage *)jarg1;
38610   arg2 = (Dali::DevelStage::Rendering)jarg2;
38611   {
38612     try {
38613       DevelStage::SetRenderingBehavior(*arg1,arg2);
38614     } catch (std::out_of_range& e) {
38615       {
38616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38617       };
38618     } catch (std::exception& e) {
38619       {
38620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38621       };
38622     } catch (Dali::DaliException e) {
38623       {
38624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38625       };
38626     } catch (...) {
38627       {
38628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38629       };
38630     }
38631   }
38632
38633 }
38634
38635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38636
38637   int jresult ;
38638   int result ;
38639   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38640
38641   arg1 = (Dali::Stage *)jarg1;
38642   {
38643     try {
38644       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38645     } catch (std::out_of_range& e) {
38646       {
38647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38648       };
38649     } catch (std::exception& e) {
38650       {
38651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38652       };
38653     } catch (Dali::DaliException e) {
38654       {
38655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38656       };
38657     } catch (...) {
38658       {
38659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38660       };
38661     }
38662   }
38663
38664   jresult = result;
38665   return jresult;
38666 }
38667
38668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38669   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38670
38671   arg1 = (Dali::RelayoutContainer *)jarg1;
38672   {
38673     try {
38674       delete arg1;
38675     } catch (std::out_of_range& e) {
38676       {
38677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38678       };
38679     } catch (std::exception& e) {
38680       {
38681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38682       };
38683     } catch (Dali::DaliException e) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38686       };
38687     } catch (...) {
38688       {
38689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38690       };
38691     }
38692   }
38693
38694 }
38695
38696
38697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38698   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38699   Dali::Actor *arg2 = 0 ;
38700   Dali::Vector2 *arg3 = 0 ;
38701
38702   arg1 = (Dali::RelayoutContainer *)jarg1;
38703   arg2 = (Dali::Actor *)jarg2;
38704   if (!arg2) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38706     return ;
38707   }
38708   arg3 = (Dali::Vector2 *)jarg3;
38709   if (!arg3) {
38710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38711     return ;
38712   }
38713   {
38714     try {
38715       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38716     } catch (std::out_of_range& e) {
38717       {
38718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38719       };
38720     } catch (std::exception& e) {
38721       {
38722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38723       };
38724     } catch (Dali::DaliException e) {
38725       {
38726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38727       };
38728     } catch (...) {
38729       {
38730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38731       };
38732     }
38733   }
38734
38735 }
38736
38737
38738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38739   void * jresult ;
38740   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38741   Dali::CustomActor result;
38742
38743   arg1 = (Dali::CustomActorImpl *)jarg1;
38744   {
38745     try {
38746       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38747     } catch (std::out_of_range& e) {
38748       {
38749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (std::exception& e) {
38752       {
38753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (Dali::DaliException e) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38758       };
38759     } catch (...) {
38760       {
38761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38762       };
38763     }
38764   }
38765
38766   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38767   return jresult;
38768 }
38769
38770
38771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38772   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38773   int arg2 ;
38774
38775   arg1 = (Dali::CustomActorImpl *)jarg1;
38776   arg2 = (int)jarg2;
38777   {
38778     try {
38779       (arg1)->OnSceneConnection(arg2);
38780     } catch (std::out_of_range& e) {
38781       {
38782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38783       };
38784     } catch (std::exception& e) {
38785       {
38786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38787       };
38788     } catch (Dali::DaliException e) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38791       };
38792     } catch (...) {
38793       {
38794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38795       };
38796     }
38797   }
38798
38799 }
38800
38801
38802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38803   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38804
38805   arg1 = (Dali::CustomActorImpl *)jarg1;
38806   {
38807     try {
38808       (arg1)->OnSceneDisconnection();
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38816       };
38817     } catch (Dali::DaliException e) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38820       };
38821     } catch (...) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38824       };
38825     }
38826   }
38827
38828 }
38829
38830
38831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38832   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38833   Dali::Actor *arg2 = 0 ;
38834
38835   arg1 = (Dali::CustomActorImpl *)jarg1;
38836   arg2 = (Dali::Actor *)jarg2;
38837   if (!arg2) {
38838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38839     return ;
38840   }
38841   {
38842     try {
38843       (arg1)->OnChildAdd(*arg2);
38844     } catch (std::out_of_range& e) {
38845       {
38846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38847       };
38848     } catch (std::exception& e) {
38849       {
38850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38851       };
38852     } catch (Dali::DaliException e) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38855       };
38856     } catch (...) {
38857       {
38858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38859       };
38860     }
38861   }
38862
38863 }
38864
38865
38866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38867   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38868   Dali::Actor *arg2 = 0 ;
38869
38870   arg1 = (Dali::CustomActorImpl *)jarg1;
38871   arg2 = (Dali::Actor *)jarg2;
38872   if (!arg2) {
38873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38874     return ;
38875   }
38876   {
38877     try {
38878       (arg1)->OnChildRemove(*arg2);
38879     } catch (std::out_of_range& e) {
38880       {
38881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38882       };
38883     } catch (std::exception& e) {
38884       {
38885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38886       };
38887     } catch (Dali::DaliException e) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38894       };
38895     }
38896   }
38897
38898 }
38899
38900
38901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38902   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38903   Dali::Property::Index arg2 ;
38904   Dali::Property::Value arg3 ;
38905   Dali::Property::Value *argp3 ;
38906
38907   arg1 = (Dali::CustomActorImpl *)jarg1;
38908   arg2 = (Dali::Property::Index)jarg2;
38909   argp3 = (Dali::Property::Value *)jarg3;
38910   if (!argp3) {
38911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38912     return ;
38913   }
38914   arg3 = *argp3;
38915   {
38916     try {
38917       (arg1)->OnPropertySet(arg2,arg3);
38918     } catch (std::out_of_range& e) {
38919       {
38920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38921       };
38922     } catch (std::exception& e) {
38923       {
38924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38925       };
38926     } catch (Dali::DaliException e) {
38927       {
38928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38929       };
38930     } catch (...) {
38931       {
38932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38933       };
38934     }
38935   }
38936
38937 }
38938
38939
38940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38941   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38942   Dali::Vector3 *arg2 = 0 ;
38943
38944   arg1 = (Dali::CustomActorImpl *)jarg1;
38945   arg2 = (Dali::Vector3 *)jarg2;
38946   if (!arg2) {
38947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38948     return ;
38949   }
38950   {
38951     try {
38952       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38953     } catch (std::out_of_range& e) {
38954       {
38955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38956       };
38957     } catch (std::exception& e) {
38958       {
38959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38960       };
38961     } catch (Dali::DaliException e) {
38962       {
38963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38964       };
38965     } catch (...) {
38966       {
38967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38968       };
38969     }
38970   }
38971
38972 }
38973
38974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38975   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38976   Dali::Animation *arg2 = 0 ;
38977   Dali::Vector3 *arg3 = 0 ;
38978
38979   arg1 = (Dali::CustomActorImpl *)jarg1;
38980   arg2 = (Dali::Animation *)jarg2;
38981   if (!arg2) {
38982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38983     return ;
38984   }
38985   arg3 = (Dali::Vector3 *)jarg3;
38986   if (!arg3) {
38987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38988     return ;
38989   }
38990   {
38991     try {
38992       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38993     } catch (std::out_of_range& e) {
38994       {
38995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38996       };
38997     } catch (std::exception& e) {
38998       {
38999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39000       };
39001     } catch (Dali::DaliException e) {
39002       {
39003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39004       };
39005     } catch (...) {
39006       {
39007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39008       };
39009     }
39010   }
39011 }
39012
39013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39014   unsigned int jresult ;
39015   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39016   Dali::HoverEvent *arg2 = 0 ;
39017   bool result;
39018
39019   arg1 = (Dali::CustomActorImpl *)jarg1;
39020   arg2 = (Dali::HoverEvent *)jarg2;
39021   if (!arg2) {
39022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39023     return 0;
39024   }
39025   {
39026     try {
39027       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39028     } catch (std::out_of_range& e) {
39029       {
39030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39031       };
39032     } catch (std::exception& e) {
39033       {
39034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39035       };
39036     } catch (Dali::DaliException e) {
39037       {
39038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39039       };
39040     } catch (...) {
39041       {
39042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39043       };
39044     }
39045   }
39046
39047   jresult = result;
39048   return jresult;
39049 }
39050
39051
39052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39053   unsigned int jresult ;
39054   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39055   Dali::KeyEvent *arg2 = 0 ;
39056   bool result;
39057
39058   arg1 = (Dali::CustomActorImpl *)jarg1;
39059   arg2 = (Dali::KeyEvent *)jarg2;
39060   if (!arg2) {
39061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39062     return 0;
39063   }
39064   {
39065     try {
39066       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39067     } catch (std::out_of_range& e) {
39068       {
39069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39070       };
39071     } catch (std::exception& e) {
39072       {
39073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (Dali::DaliException e) {
39076       {
39077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39078       };
39079     } catch (...) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39082       };
39083     }
39084   }
39085
39086   jresult = result;
39087   return jresult;
39088 }
39089
39090
39091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39092   unsigned int jresult ;
39093   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39094   Dali::WheelEvent *arg2 = 0 ;
39095   bool result;
39096
39097   arg1 = (Dali::CustomActorImpl *)jarg1;
39098   arg2 = (Dali::WheelEvent *)jarg2;
39099   if (!arg2) {
39100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39101     return 0;
39102   }
39103   {
39104     try {
39105       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39106     } catch (std::out_of_range& e) {
39107       {
39108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39109       };
39110     } catch (std::exception& e) {
39111       {
39112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39113       };
39114     } catch (Dali::DaliException e) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39117       };
39118     } catch (...) {
39119       {
39120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39121       };
39122     }
39123   }
39124
39125   jresult = result;
39126   return jresult;
39127 }
39128
39129
39130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39131   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39132   Dali::Vector2 *arg2 = 0 ;
39133   Dali::RelayoutContainer *arg3 = 0 ;
39134
39135   arg1 = (Dali::CustomActorImpl *)jarg1;
39136   arg2 = (Dali::Vector2 *)jarg2;
39137   if (!arg2) {
39138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39139     return ;
39140   }
39141   arg3 = (Dali::RelayoutContainer *)jarg3;
39142   if (!arg3) {
39143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39144     return ;
39145   }
39146   {
39147     try {
39148       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39149     } catch (std::out_of_range& e) {
39150       {
39151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39152       };
39153     } catch (std::exception& e) {
39154       {
39155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39156       };
39157     } catch (Dali::DaliException e) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39160       };
39161     } catch (...) {
39162       {
39163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39164       };
39165     }
39166   }
39167
39168 }
39169
39170
39171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39172   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39173   Dali::ResizePolicy::Type arg2 ;
39174   Dali::Dimension::Type arg3 ;
39175
39176   arg1 = (Dali::CustomActorImpl *)jarg1;
39177   arg2 = (Dali::ResizePolicy::Type)jarg2;
39178   arg3 = (Dali::Dimension::Type)jarg3;
39179   {
39180     try {
39181       (arg1)->OnSetResizePolicy(arg2,arg3);
39182     } catch (std::out_of_range& e) {
39183       {
39184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39185       };
39186     } catch (std::exception& e) {
39187       {
39188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (Dali::DaliException e) {
39191       {
39192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39197       };
39198     }
39199   }
39200
39201 }
39202
39203
39204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39205   void * jresult ;
39206   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39207   Dali::Vector3 result;
39208
39209   arg1 = (Dali::CustomActorImpl *)jarg1;
39210   {
39211     try {
39212       result = (arg1)->GetNaturalSize();
39213     } catch (std::out_of_range& e) {
39214       {
39215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39216       };
39217     } catch (std::exception& e) {
39218       {
39219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39220       };
39221     } catch (Dali::DaliException e) {
39222       {
39223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39224       };
39225     } catch (...) {
39226       {
39227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39228       };
39229     }
39230   }
39231
39232   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39233   return jresult;
39234 }
39235
39236
39237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39238   float jresult ;
39239   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39240   Dali::Actor *arg2 = 0 ;
39241   Dali::Dimension::Type arg3 ;
39242   float result;
39243
39244   arg1 = (Dali::CustomActorImpl *)jarg1;
39245   arg2 = (Dali::Actor *)jarg2;
39246   if (!arg2) {
39247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39248     return 0;
39249   }
39250   arg3 = (Dali::Dimension::Type)jarg3;
39251   {
39252     try {
39253       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39254     } catch (std::out_of_range& e) {
39255       {
39256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39257       };
39258     } catch (std::exception& e) {
39259       {
39260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39261       };
39262     } catch (Dali::DaliException e) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39265       };
39266     } catch (...) {
39267       {
39268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39269       };
39270     }
39271   }
39272
39273   jresult = result;
39274   return jresult;
39275 }
39276
39277
39278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39279   float jresult ;
39280   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39281   float arg2 ;
39282   float result;
39283
39284   arg1 = (Dali::CustomActorImpl *)jarg1;
39285   arg2 = (float)jarg2;
39286   {
39287     try {
39288       result = (float)(arg1)->GetHeightForWidth(arg2);
39289     } catch (std::out_of_range& e) {
39290       {
39291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39292       };
39293     } catch (std::exception& e) {
39294       {
39295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39296       };
39297     } catch (Dali::DaliException e) {
39298       {
39299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39300       };
39301     } catch (...) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39304       };
39305     }
39306   }
39307
39308   jresult = result;
39309   return jresult;
39310 }
39311
39312
39313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39314   float jresult ;
39315   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39316   float arg2 ;
39317   float result;
39318
39319   arg1 = (Dali::CustomActorImpl *)jarg1;
39320   arg2 = (float)jarg2;
39321   {
39322     try {
39323       result = (float)(arg1)->GetWidthForHeight(arg2);
39324     } catch (std::out_of_range& e) {
39325       {
39326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39327       };
39328     } catch (std::exception& e) {
39329       {
39330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39331       };
39332     } catch (Dali::DaliException e) {
39333       {
39334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39335       };
39336     } catch (...) {
39337       {
39338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39339       };
39340     }
39341   }
39342
39343   jresult = result;
39344   return jresult;
39345 }
39346
39347
39348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39349   unsigned int jresult ;
39350   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39351   Dali::Dimension::Type arg2 ;
39352   bool result;
39353
39354   arg1 = (Dali::CustomActorImpl *)jarg1;
39355   arg2 = (Dali::Dimension::Type)jarg2;
39356   {
39357     try {
39358       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39359     } catch (std::out_of_range& e) {
39360       {
39361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39362       };
39363     } catch (std::exception& e) {
39364       {
39365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39366       };
39367     } catch (Dali::DaliException e) {
39368       {
39369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39370       };
39371     } catch (...) {
39372       {
39373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39374       };
39375     }
39376   }
39377
39378   jresult = result;
39379   return jresult;
39380 }
39381
39382
39383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39384   unsigned int jresult ;
39385   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39386   bool result;
39387
39388   arg1 = (Dali::CustomActorImpl *)jarg1;
39389   {
39390     try {
39391       result = (bool)(arg1)->RelayoutDependentOnChildren();
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (Dali::DaliException e) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39407       };
39408     }
39409   }
39410
39411   jresult = result;
39412   return jresult;
39413 }
39414
39415
39416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39417   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39418   Dali::Dimension::Type arg2 ;
39419
39420   arg1 = (Dali::CustomActorImpl *)jarg1;
39421   arg2 = (Dali::Dimension::Type)jarg2;
39422   {
39423     try {
39424       (arg1)->OnCalculateRelayoutSize(arg2);
39425     } catch (std::out_of_range& e) {
39426       {
39427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (std::exception& e) {
39430       {
39431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39432       };
39433     } catch (Dali::DaliException e) {
39434       {
39435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39436       };
39437     } catch (...) {
39438       {
39439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39440       };
39441     }
39442   }
39443
39444 }
39445
39446
39447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39448   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39449   float arg2 ;
39450   Dali::Dimension::Type arg3 ;
39451
39452   arg1 = (Dali::CustomActorImpl *)jarg1;
39453   arg2 = (float)jarg2;
39454   arg3 = (Dali::Dimension::Type)jarg3;
39455   {
39456     try {
39457       (arg1)->OnLayoutNegotiated(arg2,arg3);
39458     } catch (std::out_of_range& e) {
39459       {
39460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39461       };
39462     } catch (std::exception& e) {
39463       {
39464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39465       };
39466     } catch (Dali::DaliException e) {
39467       {
39468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39469       };
39470     } catch (...) {
39471       {
39472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39473       };
39474     }
39475   }
39476
39477 }
39478
39479
39480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39481   unsigned int jresult ;
39482   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39483   bool result;
39484
39485   arg1 = (Dali::CustomActorImpl *)jarg1;
39486   {
39487     try {
39488       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39489     } catch (std::out_of_range& e) {
39490       {
39491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39492       };
39493     } catch (std::exception& e) {
39494       {
39495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39496       };
39497     } catch (Dali::DaliException e) {
39498       {
39499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39500       };
39501     } catch (...) {
39502       {
39503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39504       };
39505     }
39506   }
39507
39508   jresult = result;
39509   return jresult;
39510 }
39511
39512
39513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39514   unsigned int jresult ;
39515   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39516   bool result;
39517
39518   arg1 = (Dali::CustomActorImpl *)jarg1;
39519   {
39520     try {
39521       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39522     } catch (std::out_of_range& e) {
39523       {
39524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39525       };
39526     } catch (std::exception& e) {
39527       {
39528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39529       };
39530     } catch (Dali::DaliException e) {
39531       {
39532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39533       };
39534     } catch (...) {
39535       {
39536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39537       };
39538     }
39539   }
39540
39541   jresult = result;
39542   return jresult;
39543 }
39544
39545
39546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39547   unsigned int jresult ;
39548   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39549   bool result;
39550
39551   arg1 = (Dali::CustomActorImpl *)jarg1;
39552   {
39553     try {
39554       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39555     } catch (std::out_of_range& e) {
39556       {
39557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39558       };
39559     } catch (std::exception& e) {
39560       {
39561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39562       };
39563     } catch (Dali::DaliException e) {
39564       {
39565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39566       };
39567     } catch (...) {
39568       {
39569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39570       };
39571     }
39572   }
39573
39574   jresult = result;
39575   return jresult;
39576 }
39577
39578
39579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39580   unsigned int jresult ;
39581   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39582   bool result;
39583
39584   arg1 = (Dali::CustomActorImpl *)jarg1;
39585   {
39586     try {
39587       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (Dali::DaliException e) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39613   void * jresult ;
39614   Dali::CustomActor *result = 0 ;
39615
39616   {
39617     try {
39618       result = (Dali::CustomActor *)new Dali::CustomActor();
39619     } catch (std::out_of_range& e) {
39620       {
39621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (std::exception& e) {
39624       {
39625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39626       };
39627     } catch (Dali::DaliException e) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39630       };
39631     } catch (...) {
39632       {
39633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39634       };
39635     }
39636   }
39637
39638   jresult = (void *)result;
39639   return jresult;
39640 }
39641
39642
39643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39644   void * jresult ;
39645   Dali::BaseHandle arg1 ;
39646   Dali::BaseHandle *argp1 ;
39647   Dali::CustomActor result;
39648
39649   argp1 = (Dali::BaseHandle *)jarg1;
39650   if (!argp1) {
39651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39652     return 0;
39653   }
39654   arg1 = *argp1;
39655   {
39656     try {
39657       result = Dali::CustomActor::DownCast(arg1);
39658     } catch (std::out_of_range& e) {
39659       {
39660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39661       };
39662     } catch (std::exception& e) {
39663       {
39664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39665       };
39666     } catch (Dali::DaliException e) {
39667       {
39668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39669       };
39670     } catch (...) {
39671       {
39672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39673       };
39674     }
39675   }
39676
39677   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39678   return jresult;
39679 }
39680
39681
39682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39683   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39684
39685   arg1 = (Dali::CustomActor *)jarg1;
39686   {
39687     try {
39688       delete arg1;
39689     } catch (std::out_of_range& e) {
39690       {
39691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39692       };
39693     } catch (std::exception& e) {
39694       {
39695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39696       };
39697     } catch (Dali::DaliException e) {
39698       {
39699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39700       };
39701     } catch (...) {
39702       {
39703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39704       };
39705     }
39706   }
39707
39708 }
39709
39710
39711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39712   void * jresult ;
39713   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39714   Dali::CustomActorImpl *result = 0 ;
39715
39716   arg1 = (Dali::CustomActor *)jarg1;
39717   {
39718     try {
39719       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39720     } catch (std::out_of_range& e) {
39721       {
39722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39723       };
39724     } catch (std::exception& e) {
39725       {
39726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39727       };
39728     } catch (Dali::DaliException e) {
39729       {
39730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39731       };
39732     } catch (...) {
39733       {
39734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39735       };
39736     }
39737   }
39738
39739   jresult = (void *)result;
39740   return jresult;
39741 }
39742
39743
39744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39745   void * jresult ;
39746   Dali::CustomActorImpl *arg1 = 0 ;
39747   Dali::CustomActor *result = 0 ;
39748
39749   arg1 = (Dali::CustomActorImpl *)jarg1;
39750   if (!arg1) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39752     return 0;
39753   }
39754   {
39755     try {
39756       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (Dali::DaliException e) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39768       };
39769     } catch (...) {
39770       {
39771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39772       };
39773     }
39774   }
39775
39776   jresult = (void *)result;
39777   return jresult;
39778 }
39779
39780
39781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39782   void * jresult ;
39783   Dali::CustomActor *arg1 = 0 ;
39784   Dali::CustomActor *result = 0 ;
39785
39786   arg1 = (Dali::CustomActor *)jarg1;
39787   if (!arg1) {
39788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39789     return 0;
39790   }
39791   {
39792     try {
39793       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39794     } catch (std::out_of_range& e) {
39795       {
39796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39797       };
39798     } catch (std::exception& e) {
39799       {
39800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39801       };
39802     } catch (Dali::DaliException e) {
39803       {
39804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39805       };
39806     } catch (...) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39809       };
39810     }
39811   }
39812
39813   jresult = (void *)result;
39814   return jresult;
39815 }
39816
39817
39818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39819   void * jresult ;
39820   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39821   Dali::CustomActor *arg2 = 0 ;
39822   Dali::CustomActor *result = 0 ;
39823
39824   arg1 = (Dali::CustomActor *)jarg1;
39825   arg2 = (Dali::CustomActor *)jarg2;
39826   if (!arg2) {
39827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39828     return 0;
39829   }
39830   {
39831     try {
39832       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39833     } catch (std::out_of_range& e) {
39834       {
39835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39836       };
39837     } catch (std::exception& e) {
39838       {
39839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39840       };
39841     } catch (Dali::DaliException e) {
39842       {
39843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39844       };
39845     } catch (...) {
39846       {
39847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39848       };
39849     }
39850   }
39851
39852   jresult = (void *)result;
39853   return jresult;
39854 }
39855
39856
39857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39858   int jresult ;
39859   int result;
39860
39861   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39862   jresult = (int)result;
39863   return jresult;
39864 }
39865
39866
39867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39868   int jresult ;
39869   int result;
39870
39871   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39872   jresult = (int)result;
39873   return jresult;
39874 }
39875
39876
39877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39878   int jresult ;
39879   int result;
39880
39881   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39882   jresult = (int)result;
39883   return jresult;
39884 }
39885
39886
39887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39888   int jresult ;
39889   int result;
39890
39891   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39892   jresult = (int)result;
39893   return jresult;
39894 }
39895
39896
39897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39898   int jresult ;
39899   int result;
39900
39901   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39902   jresult = (int)result;
39903   return jresult;
39904 }
39905
39906
39907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39908   int jresult ;
39909   int result;
39910
39911   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39912   jresult = (int)result;
39913   return jresult;
39914 }
39915
39916
39917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39918   int jresult ;
39919   int result;
39920
39921   result = (int)Dali::PanGestureDetector::Property::PANNING;
39922   jresult = (int)result;
39923   return jresult;
39924 }
39925
39926
39927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39928   void * jresult ;
39929   Dali::PanGestureDetector::Property *result = 0 ;
39930
39931   {
39932     try {
39933       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39934     } catch (std::out_of_range& e) {
39935       {
39936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39937       };
39938     } catch (std::exception& e) {
39939       {
39940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39941       };
39942     } catch (Dali::DaliException e) {
39943       {
39944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39945       };
39946     } catch (...) {
39947       {
39948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39949       };
39950     }
39951   }
39952
39953   jresult = (void *)result;
39954   return jresult;
39955 }
39956
39957
39958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39959   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39960
39961   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39962   {
39963     try {
39964       delete arg1;
39965     } catch (std::out_of_range& e) {
39966       {
39967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39968       };
39969     } catch (std::exception& e) {
39970       {
39971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39972       };
39973     } catch (Dali::DaliException e) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39976       };
39977     } catch (...) {
39978       {
39979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39980       };
39981     }
39982   }
39983
39984 }
39985
39986
39987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39988   void * jresult ;
39989   Dali::Radian *result = 0 ;
39990
39991   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39992   jresult = (void *)result;
39993   return jresult;
39994 }
39995
39996
39997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39998   void * jresult ;
39999   Dali::Radian *result = 0 ;
40000
40001   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40002   jresult = (void *)result;
40003   return jresult;
40004 }
40005
40006
40007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40008   void * jresult ;
40009   Dali::Radian *result = 0 ;
40010
40011   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40012   jresult = (void *)result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40018   void * jresult ;
40019   Dali::Radian *result = 0 ;
40020
40021   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40022   jresult = (void *)result;
40023   return jresult;
40024 }
40025
40026
40027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40028   void * jresult ;
40029   Dali::Radian *result = 0 ;
40030
40031   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40032   jresult = (void *)result;
40033   return jresult;
40034 }
40035
40036
40037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40038   void * jresult ;
40039   Dali::Radian *result = 0 ;
40040
40041   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40042   jresult = (void *)result;
40043   return jresult;
40044 }
40045
40046
40047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40048   void * jresult ;
40049   Dali::Radian *result = 0 ;
40050
40051   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40052   jresult = (void *)result;
40053   return jresult;
40054 }
40055
40056
40057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40058   void * jresult ;
40059   Dali::PanGestureDetector *result = 0 ;
40060
40061   {
40062     try {
40063       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40064     } catch (std::out_of_range& e) {
40065       {
40066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40067       };
40068     } catch (std::exception& e) {
40069       {
40070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40071       };
40072     } catch (Dali::DaliException e) {
40073       {
40074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40075       };
40076     } catch (...) {
40077       {
40078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40079       };
40080     }
40081   }
40082
40083   jresult = (void *)result;
40084   return jresult;
40085 }
40086
40087
40088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40089   void * jresult ;
40090   Dali::PanGestureDetector result;
40091
40092   {
40093     try {
40094       result = Dali::PanGestureDetector::New();
40095     } catch (std::out_of_range& e) {
40096       {
40097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40098       };
40099     } catch (std::exception& e) {
40100       {
40101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40102       };
40103     } catch (Dali::DaliException e) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40106       };
40107     } catch (...) {
40108       {
40109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40110       };
40111     }
40112   }
40113
40114   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40120   void * jresult ;
40121   Dali::BaseHandle arg1 ;
40122   Dali::BaseHandle *argp1 ;
40123   Dali::PanGestureDetector result;
40124
40125   argp1 = (Dali::BaseHandle *)jarg1;
40126   if (!argp1) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40128     return 0;
40129   }
40130   arg1 = *argp1;
40131   {
40132     try {
40133       result = Dali::PanGestureDetector::DownCast(arg1);
40134     } catch (std::out_of_range& e) {
40135       {
40136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40137       };
40138     } catch (std::exception& e) {
40139       {
40140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40141       };
40142     } catch (Dali::DaliException e) {
40143       {
40144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40145       };
40146     } catch (...) {
40147       {
40148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40149       };
40150     }
40151   }
40152
40153   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40154   return jresult;
40155 }
40156
40157
40158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40159   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40160
40161   arg1 = (Dali::PanGestureDetector *)jarg1;
40162   {
40163     try {
40164       delete arg1;
40165     } catch (std::out_of_range& e) {
40166       {
40167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40168       };
40169     } catch (std::exception& e) {
40170       {
40171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40172       };
40173     } catch (Dali::DaliException e) {
40174       {
40175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40176       };
40177     } catch (...) {
40178       {
40179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40180       };
40181     }
40182   }
40183
40184 }
40185
40186
40187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40188   void * jresult ;
40189   Dali::PanGestureDetector *arg1 = 0 ;
40190   Dali::PanGestureDetector *result = 0 ;
40191
40192   arg1 = (Dali::PanGestureDetector *)jarg1;
40193   if (!arg1) {
40194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40195     return 0;
40196   }
40197   {
40198     try {
40199       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40200     } catch (std::out_of_range& e) {
40201       {
40202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40203       };
40204     } catch (std::exception& e) {
40205       {
40206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40207       };
40208     } catch (Dali::DaliException e) {
40209       {
40210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40211       };
40212     } catch (...) {
40213       {
40214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40215       };
40216     }
40217   }
40218
40219   jresult = (void *)result;
40220   return jresult;
40221 }
40222
40223
40224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40225   void * jresult ;
40226   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40227   Dali::PanGestureDetector *arg2 = 0 ;
40228   Dali::PanGestureDetector *result = 0 ;
40229
40230   arg1 = (Dali::PanGestureDetector *)jarg1;
40231   arg2 = (Dali::PanGestureDetector *)jarg2;
40232   if (!arg2) {
40233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40234     return 0;
40235   }
40236   {
40237     try {
40238       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40239     } catch (std::out_of_range& e) {
40240       {
40241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40242       };
40243     } catch (std::exception& e) {
40244       {
40245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40246       };
40247     } catch (Dali::DaliException e) {
40248       {
40249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40250       };
40251     } catch (...) {
40252       {
40253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40254       };
40255     }
40256   }
40257
40258   jresult = (void *)result;
40259   return jresult;
40260 }
40261
40262
40263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40264   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40265   unsigned int arg2 ;
40266
40267   arg1 = (Dali::PanGestureDetector *)jarg1;
40268   arg2 = (unsigned int)jarg2;
40269   {
40270     try {
40271       (arg1)->SetMinimumTouchesRequired(arg2);
40272     } catch (std::out_of_range& e) {
40273       {
40274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40275       };
40276     } catch (std::exception& e) {
40277       {
40278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40279       };
40280     } catch (Dali::DaliException e) {
40281       {
40282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40283       };
40284     } catch (...) {
40285       {
40286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40287       };
40288     }
40289   }
40290
40291 }
40292
40293
40294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40295   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40296   unsigned int arg2 ;
40297
40298   arg1 = (Dali::PanGestureDetector *)jarg1;
40299   arg2 = (unsigned int)jarg2;
40300   {
40301     try {
40302       (arg1)->SetMaximumTouchesRequired(arg2);
40303     } catch (std::out_of_range& e) {
40304       {
40305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40306       };
40307     } catch (std::exception& e) {
40308       {
40309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40310       };
40311     } catch (Dali::DaliException e) {
40312       {
40313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40314       };
40315     } catch (...) {
40316       {
40317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40318       };
40319     }
40320   }
40321
40322 }
40323
40324
40325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40326   unsigned int jresult ;
40327   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40328   unsigned int result;
40329
40330   arg1 = (Dali::PanGestureDetector *)jarg1;
40331   {
40332     try {
40333       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40334     } catch (std::out_of_range& e) {
40335       {
40336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40337       };
40338     } catch (std::exception& e) {
40339       {
40340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40341       };
40342     } catch (Dali::DaliException e) {
40343       {
40344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40345       };
40346     } catch (...) {
40347       {
40348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40349       };
40350     }
40351   }
40352
40353   jresult = result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40359   unsigned int jresult ;
40360   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40361   unsigned int result;
40362
40363   arg1 = (Dali::PanGestureDetector *)jarg1;
40364   {
40365     try {
40366       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40367     } catch (std::out_of_range& e) {
40368       {
40369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40370       };
40371     } catch (std::exception& e) {
40372       {
40373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40374       };
40375     } catch (Dali::DaliException e) {
40376       {
40377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40378       };
40379     } catch (...) {
40380       {
40381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40382       };
40383     }
40384   }
40385
40386   jresult = result;
40387   return jresult;
40388 }
40389
40390
40391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40392   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40393   Dali::Radian arg2 ;
40394   Dali::Radian arg3 ;
40395   Dali::Radian *argp2 ;
40396   Dali::Radian *argp3 ;
40397
40398   arg1 = (Dali::PanGestureDetector *)jarg1;
40399   argp2 = (Dali::Radian *)jarg2;
40400   if (!argp2) {
40401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40402     return ;
40403   }
40404   arg2 = *argp2;
40405   argp3 = (Dali::Radian *)jarg3;
40406   if (!argp3) {
40407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40408     return ;
40409   }
40410   arg3 = *argp3;
40411   {
40412     try {
40413       (arg1)->AddAngle(arg2,arg3);
40414     } catch (std::out_of_range& e) {
40415       {
40416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40417       };
40418     } catch (std::exception& e) {
40419       {
40420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40421       };
40422     } catch (Dali::DaliException e) {
40423       {
40424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40425       };
40426     } catch (...) {
40427       {
40428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40429       };
40430     }
40431   }
40432
40433 }
40434
40435
40436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40437   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40438   Dali::Radian arg2 ;
40439   Dali::Radian *argp2 ;
40440
40441   arg1 = (Dali::PanGestureDetector *)jarg1;
40442   argp2 = (Dali::Radian *)jarg2;
40443   if (!argp2) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40445     return ;
40446   }
40447   arg2 = *argp2;
40448   {
40449     try {
40450       (arg1)->AddAngle(arg2);
40451     } catch (std::out_of_range& e) {
40452       {
40453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40454       };
40455     } catch (std::exception& e) {
40456       {
40457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (Dali::DaliException e) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40462       };
40463     } catch (...) {
40464       {
40465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40466       };
40467     }
40468   }
40469
40470 }
40471
40472
40473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40474   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40475   Dali::Radian arg2 ;
40476   Dali::Radian arg3 ;
40477   Dali::Radian *argp2 ;
40478   Dali::Radian *argp3 ;
40479
40480   arg1 = (Dali::PanGestureDetector *)jarg1;
40481   argp2 = (Dali::Radian *)jarg2;
40482   if (!argp2) {
40483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40484     return ;
40485   }
40486   arg2 = *argp2;
40487   argp3 = (Dali::Radian *)jarg3;
40488   if (!argp3) {
40489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40490     return ;
40491   }
40492   arg3 = *argp3;
40493   {
40494     try {
40495       (arg1)->AddDirection(arg2,arg3);
40496     } catch (std::out_of_range& e) {
40497       {
40498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40499       };
40500     } catch (std::exception& e) {
40501       {
40502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40503       };
40504     } catch (Dali::DaliException e) {
40505       {
40506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40507       };
40508     } catch (...) {
40509       {
40510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40511       };
40512     }
40513   }
40514
40515 }
40516
40517
40518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40519   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40520   Dali::Radian arg2 ;
40521   Dali::Radian *argp2 ;
40522
40523   arg1 = (Dali::PanGestureDetector *)jarg1;
40524   argp2 = (Dali::Radian *)jarg2;
40525   if (!argp2) {
40526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40527     return ;
40528   }
40529   arg2 = *argp2;
40530   {
40531     try {
40532       (arg1)->AddDirection(arg2);
40533     } catch (std::out_of_range& e) {
40534       {
40535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40536       };
40537     } catch (std::exception& e) {
40538       {
40539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40540       };
40541     } catch (Dali::DaliException e) {
40542       {
40543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40544       };
40545     } catch (...) {
40546       {
40547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40548       };
40549     }
40550   }
40551
40552 }
40553
40554
40555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40556   unsigned long jresult ;
40557   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40558   size_t result;
40559
40560   arg1 = (Dali::PanGestureDetector *)jarg1;
40561   {
40562     try {
40563       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40564     } catch (std::out_of_range& e) {
40565       {
40566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (std::exception& e) {
40569       {
40570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40571       };
40572     } catch (Dali::DaliException e) {
40573       {
40574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40575       };
40576     } catch (...) {
40577       {
40578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40579       };
40580     }
40581   }
40582
40583   jresult = (unsigned long)result;
40584   return jresult;
40585 }
40586
40587
40588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40589   void * jresult ;
40590   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40591   size_t arg2 ;
40592   Dali::PanGestureDetector::AngleThresholdPair result;
40593
40594   arg1 = (Dali::PanGestureDetector *)jarg1;
40595   arg2 = (size_t)jarg2;
40596   {
40597     try {
40598       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40599     } catch (std::out_of_range& e) {
40600       {
40601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40602       };
40603     } catch (std::exception& e) {
40604       {
40605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40606       };
40607     } catch (Dali::DaliException e) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40610       };
40611     } catch (...) {
40612       {
40613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40614       };
40615     }
40616   }
40617
40618   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40619   return jresult;
40620 }
40621
40622
40623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40624   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40625
40626   arg1 = (Dali::PanGestureDetector *)jarg1;
40627   {
40628     try {
40629       (arg1)->ClearAngles();
40630     } catch (std::out_of_range& e) {
40631       {
40632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40633       };
40634     } catch (std::exception& e) {
40635       {
40636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40637       };
40638     } catch (Dali::DaliException e) {
40639       {
40640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40641       };
40642     } catch (...) {
40643       {
40644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40645       };
40646     }
40647   }
40648
40649 }
40650
40651
40652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40653   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40654   Dali::Radian arg2 ;
40655   Dali::Radian *argp2 ;
40656
40657   arg1 = (Dali::PanGestureDetector *)jarg1;
40658   argp2 = (Dali::Radian *)jarg2;
40659   if (!argp2) {
40660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40661     return ;
40662   }
40663   arg2 = *argp2;
40664   {
40665     try {
40666       (arg1)->RemoveAngle(arg2);
40667     } catch (std::out_of_range& e) {
40668       {
40669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40670       };
40671     } catch (std::exception& e) {
40672       {
40673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40674       };
40675     } catch (Dali::DaliException e) {
40676       {
40677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40678       };
40679     } catch (...) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40682       };
40683     }
40684   }
40685
40686 }
40687
40688
40689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40690   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40691   Dali::Radian arg2 ;
40692   Dali::Radian *argp2 ;
40693
40694   arg1 = (Dali::PanGestureDetector *)jarg1;
40695   argp2 = (Dali::Radian *)jarg2;
40696   if (!argp2) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40698     return ;
40699   }
40700   arg2 = *argp2;
40701   {
40702     try {
40703       (arg1)->RemoveDirection(arg2);
40704     } catch (std::out_of_range& e) {
40705       {
40706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40707       };
40708     } catch (std::exception& e) {
40709       {
40710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40711       };
40712     } catch (Dali::DaliException e) {
40713       {
40714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40715       };
40716     } catch (...) {
40717       {
40718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40719       };
40720     }
40721   }
40722
40723 }
40724
40725
40726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40727   void * jresult ;
40728   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40729   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40730
40731   arg1 = (Dali::PanGestureDetector *)jarg1;
40732   {
40733     try {
40734       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40735     } catch (std::out_of_range& e) {
40736       {
40737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40738       };
40739     } catch (std::exception& e) {
40740       {
40741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40742       };
40743     } catch (Dali::DaliException e) {
40744       {
40745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40746       };
40747     } catch (...) {
40748       {
40749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40750       };
40751     }
40752   }
40753
40754   jresult = (void *)result;
40755   return jresult;
40756 }
40757
40758
40759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40760   Dali::PanGesture *arg1 = 0 ;
40761
40762   arg1 = (Dali::PanGesture *)jarg1;
40763   if (!arg1) {
40764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40765     return ;
40766   }
40767   {
40768     try {
40769       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40770     } catch (std::out_of_range& e) {
40771       {
40772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40773       };
40774     } catch (std::exception& e) {
40775       {
40776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40777       };
40778     } catch (Dali::DaliException e) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40781       };
40782     } catch (...) {
40783       {
40784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40785       };
40786     }
40787   }
40788
40789 }
40790
40791
40792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40793   void * jresult ;
40794   Dali::PanGesture *result = 0 ;
40795
40796   {
40797     try {
40798       result = (Dali::PanGesture *)new Dali::PanGesture();
40799     } catch (std::out_of_range& e) {
40800       {
40801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (std::exception& e) {
40804       {
40805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40806       };
40807     } catch (Dali::DaliException e) {
40808       {
40809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40810       };
40811     } catch (...) {
40812       {
40813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40814       };
40815     }
40816   }
40817
40818   jresult = (void *)result;
40819   return jresult;
40820 }
40821
40822
40823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40824   void * jresult ;
40825   Dali::Gesture::State arg1 ;
40826   Dali::PanGesture *result = 0 ;
40827
40828   arg1 = (Dali::Gesture::State)jarg1;
40829   {
40830     try {
40831       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40832     } catch (std::out_of_range& e) {
40833       {
40834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40835       };
40836     } catch (std::exception& e) {
40837       {
40838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40839       };
40840     } catch (Dali::DaliException e) {
40841       {
40842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40843       };
40844     } catch (...) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40847       };
40848     }
40849   }
40850
40851   jresult = (void *)result;
40852   return jresult;
40853 }
40854
40855
40856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40857   void * jresult ;
40858   Dali::PanGesture *arg1 = 0 ;
40859   Dali::PanGesture *result = 0 ;
40860
40861   arg1 = (Dali::PanGesture *)jarg1;
40862   if (!arg1) {
40863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40864     return 0;
40865   }
40866   {
40867     try {
40868       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40869     } catch (std::out_of_range& e) {
40870       {
40871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40872       };
40873     } catch (std::exception& e) {
40874       {
40875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40876       };
40877     } catch (Dali::DaliException e) {
40878       {
40879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40880       };
40881     } catch (...) {
40882       {
40883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40884       };
40885     }
40886   }
40887
40888   jresult = (void *)result;
40889   return jresult;
40890 }
40891
40892
40893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40894   void * jresult ;
40895   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40896   Dali::PanGesture *arg2 = 0 ;
40897   Dali::PanGesture *result = 0 ;
40898
40899   arg1 = (Dali::PanGesture *)jarg1;
40900   arg2 = (Dali::PanGesture *)jarg2;
40901   if (!arg2) {
40902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40903     return 0;
40904   }
40905   {
40906     try {
40907       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40908     } catch (std::out_of_range& e) {
40909       {
40910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40911       };
40912     } catch (std::exception& e) {
40913       {
40914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40915       };
40916     } catch (Dali::DaliException e) {
40917       {
40918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40919       };
40920     } catch (...) {
40921       {
40922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40923       };
40924     }
40925   }
40926
40927   jresult = (void *)result;
40928   return jresult;
40929 }
40930
40931
40932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40933   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40934
40935   arg1 = (Dali::PanGesture *)jarg1;
40936   {
40937     try {
40938       delete arg1;
40939     } catch (std::out_of_range& e) {
40940       {
40941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40942       };
40943     } catch (std::exception& e) {
40944       {
40945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40946       };
40947     } catch (Dali::DaliException e) {
40948       {
40949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40950       };
40951     } catch (...) {
40952       {
40953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40954       };
40955     }
40956   }
40957
40958 }
40959
40960
40961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40962   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40963   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40964
40965   arg1 = (Dali::PanGesture *)jarg1;
40966   arg2 = (Dali::Vector2 *)jarg2;
40967   if (arg1) (arg1)->velocity = *arg2;
40968 }
40969
40970
40971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40972   void * jresult ;
40973   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40974   Dali::Vector2 *result = 0 ;
40975
40976   arg1 = (Dali::PanGesture *)jarg1;
40977   result = (Dali::Vector2 *)& ((arg1)->velocity);
40978   jresult = (void *)result;
40979   return jresult;
40980 }
40981
40982
40983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40984   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40985   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40986
40987   arg1 = (Dali::PanGesture *)jarg1;
40988   arg2 = (Dali::Vector2 *)jarg2;
40989   if (arg1) (arg1)->displacement = *arg2;
40990 }
40991
40992
40993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40994   void * jresult ;
40995   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40996   Dali::Vector2 *result = 0 ;
40997
40998   arg1 = (Dali::PanGesture *)jarg1;
40999   result = (Dali::Vector2 *)& ((arg1)->displacement);
41000   jresult = (void *)result;
41001   return jresult;
41002 }
41003
41004
41005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41006   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41007   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41008
41009   arg1 = (Dali::PanGesture *)jarg1;
41010   arg2 = (Dali::Vector2 *)jarg2;
41011   if (arg1) (arg1)->position = *arg2;
41012 }
41013
41014
41015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41016   void * jresult ;
41017   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41018   Dali::Vector2 *result = 0 ;
41019
41020   arg1 = (Dali::PanGesture *)jarg1;
41021   result = (Dali::Vector2 *)& ((arg1)->position);
41022   jresult = (void *)result;
41023   return jresult;
41024 }
41025
41026
41027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41028   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41029   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41030
41031   arg1 = (Dali::PanGesture *)jarg1;
41032   arg2 = (Dali::Vector2 *)jarg2;
41033   if (arg1) (arg1)->screenVelocity = *arg2;
41034 }
41035
41036
41037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41038   void * jresult ;
41039   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41040   Dali::Vector2 *result = 0 ;
41041
41042   arg1 = (Dali::PanGesture *)jarg1;
41043   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41050   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41051   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41052
41053   arg1 = (Dali::PanGesture *)jarg1;
41054   arg2 = (Dali::Vector2 *)jarg2;
41055   if (arg1) (arg1)->screenDisplacement = *arg2;
41056 }
41057
41058
41059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41060   void * jresult ;
41061   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41062   Dali::Vector2 *result = 0 ;
41063
41064   arg1 = (Dali::PanGesture *)jarg1;
41065   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41066   jresult = (void *)result;
41067   return jresult;
41068 }
41069
41070
41071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41072   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41073   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41074
41075   arg1 = (Dali::PanGesture *)jarg1;
41076   arg2 = (Dali::Vector2 *)jarg2;
41077   if (arg1) (arg1)->screenPosition = *arg2;
41078 }
41079
41080
41081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41082   void * jresult ;
41083   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41084   Dali::Vector2 *result = 0 ;
41085
41086   arg1 = (Dali::PanGesture *)jarg1;
41087   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41088   jresult = (void *)result;
41089   return jresult;
41090 }
41091
41092
41093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41094   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41095   unsigned int arg2 ;
41096
41097   arg1 = (Dali::PanGesture *)jarg1;
41098   arg2 = (unsigned int)jarg2;
41099   if (arg1) (arg1)->numberOfTouches = arg2;
41100 }
41101
41102
41103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41104   unsigned int jresult ;
41105   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41106   unsigned int result;
41107
41108   arg1 = (Dali::PanGesture *)jarg1;
41109   result = (unsigned int) ((arg1)->numberOfTouches);
41110   jresult = result;
41111   return jresult;
41112 }
41113
41114
41115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41116   float jresult ;
41117   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41118   float result;
41119
41120   arg1 = (Dali::PanGesture *)jarg1;
41121   {
41122     try {
41123       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41124     } catch (std::out_of_range& e) {
41125       {
41126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (std::exception& e) {
41129       {
41130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41131       };
41132     } catch (Dali::DaliException e) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41135       };
41136     } catch (...) {
41137       {
41138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41139       };
41140     }
41141   }
41142
41143   jresult = result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41149   float jresult ;
41150   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41151   float result;
41152
41153   arg1 = (Dali::PanGesture *)jarg1;
41154   {
41155     try {
41156       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41157     } catch (std::out_of_range& e) {
41158       {
41159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (std::exception& e) {
41162       {
41163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41164       };
41165     } catch (Dali::DaliException e) {
41166       {
41167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41168       };
41169     } catch (...) {
41170       {
41171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41172       };
41173     }
41174   }
41175
41176   jresult = result;
41177   return jresult;
41178 }
41179
41180
41181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41182   float jresult ;
41183   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41184   float result;
41185
41186   arg1 = (Dali::PanGesture *)jarg1;
41187   {
41188     try {
41189       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41205       };
41206     }
41207   }
41208
41209   jresult = result;
41210   return jresult;
41211 }
41212
41213
41214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41215   float jresult ;
41216   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41217   float result;
41218
41219   arg1 = (Dali::PanGesture *)jarg1;
41220   {
41221     try {
41222       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41223     } catch (std::out_of_range& e) {
41224       {
41225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41226       };
41227     } catch (std::exception& e) {
41228       {
41229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41230       };
41231     } catch (Dali::DaliException e) {
41232       {
41233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41234       };
41235     } catch (...) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41238       };
41239     }
41240   }
41241
41242   jresult = result;
41243   return jresult;
41244 }
41245
41246
41247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41248   void * jresult ;
41249   Dali::PinchGestureDetector *result = 0 ;
41250
41251   {
41252     try {
41253       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41254     } catch (std::out_of_range& e) {
41255       {
41256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41257       };
41258     } catch (std::exception& e) {
41259       {
41260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41261       };
41262     } catch (Dali::DaliException e) {
41263       {
41264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41265       };
41266     } catch (...) {
41267       {
41268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41269       };
41270     }
41271   }
41272
41273   jresult = (void *)result;
41274   return jresult;
41275 }
41276
41277
41278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41279   void * jresult ;
41280   Dali::PinchGestureDetector result;
41281
41282   {
41283     try {
41284       result = Dali::PinchGestureDetector::New();
41285     } catch (std::out_of_range& e) {
41286       {
41287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41288       };
41289     } catch (std::exception& e) {
41290       {
41291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41292       };
41293     } catch (Dali::DaliException e) {
41294       {
41295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41296       };
41297     } catch (...) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41300       };
41301     }
41302   }
41303
41304   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41305   return jresult;
41306 }
41307
41308
41309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41310   void * jresult ;
41311   Dali::BaseHandle arg1 ;
41312   Dali::BaseHandle *argp1 ;
41313   Dali::PinchGestureDetector result;
41314
41315   argp1 = (Dali::BaseHandle *)jarg1;
41316   if (!argp1) {
41317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41318     return 0;
41319   }
41320   arg1 = *argp1;
41321   {
41322     try {
41323       result = Dali::PinchGestureDetector::DownCast(arg1);
41324     } catch (std::out_of_range& e) {
41325       {
41326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41327       };
41328     } catch (std::exception& e) {
41329       {
41330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41331       };
41332     } catch (Dali::DaliException e) {
41333       {
41334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41335       };
41336     } catch (...) {
41337       {
41338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41339       };
41340     }
41341   }
41342
41343   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41344   return jresult;
41345 }
41346
41347
41348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41349   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41350
41351   arg1 = (Dali::PinchGestureDetector *)jarg1;
41352   {
41353     try {
41354       delete arg1;
41355     } catch (std::out_of_range& e) {
41356       {
41357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41358       };
41359     } catch (std::exception& e) {
41360       {
41361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41362       };
41363     } catch (Dali::DaliException e) {
41364       {
41365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41366       };
41367     } catch (...) {
41368       {
41369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41370       };
41371     }
41372   }
41373
41374 }
41375
41376
41377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41378   void * jresult ;
41379   Dali::PinchGestureDetector *arg1 = 0 ;
41380   Dali::PinchGestureDetector *result = 0 ;
41381
41382   arg1 = (Dali::PinchGestureDetector *)jarg1;
41383   if (!arg1) {
41384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41385     return 0;
41386   }
41387   {
41388     try {
41389       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41390     } catch (std::out_of_range& e) {
41391       {
41392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (std::exception& e) {
41395       {
41396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41397       };
41398     } catch (Dali::DaliException e) {
41399       {
41400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41401       };
41402     } catch (...) {
41403       {
41404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41405       };
41406     }
41407   }
41408
41409   jresult = (void *)result;
41410   return jresult;
41411 }
41412
41413
41414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41415   void * jresult ;
41416   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41417   Dali::PinchGestureDetector *arg2 = 0 ;
41418   Dali::PinchGestureDetector *result = 0 ;
41419
41420   arg1 = (Dali::PinchGestureDetector *)jarg1;
41421   arg2 = (Dali::PinchGestureDetector *)jarg2;
41422   if (!arg2) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41424     return 0;
41425   }
41426   {
41427     try {
41428       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41429     } catch (std::out_of_range& e) {
41430       {
41431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (std::exception& e) {
41434       {
41435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (Dali::DaliException e) {
41438       {
41439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41454   void * jresult ;
41455   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41456   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41457
41458   arg1 = (Dali::PinchGestureDetector *)jarg1;
41459   {
41460     try {
41461       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41462     } catch (std::out_of_range& e) {
41463       {
41464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41465       };
41466     } catch (std::exception& e) {
41467       {
41468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41469       };
41470     } catch (Dali::DaliException e) {
41471       {
41472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41473       };
41474     } catch (...) {
41475       {
41476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41477       };
41478     }
41479   }
41480
41481   jresult = (void *)result;
41482   return jresult;
41483 }
41484
41485
41486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41487   void * jresult ;
41488   Dali::Gesture::State arg1 ;
41489   Dali::PinchGesture *result = 0 ;
41490
41491   arg1 = (Dali::Gesture::State)jarg1;
41492   {
41493     try {
41494       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41495     } catch (std::out_of_range& e) {
41496       {
41497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41498       };
41499     } catch (std::exception& e) {
41500       {
41501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41502       };
41503     } catch (Dali::DaliException e) {
41504       {
41505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41506       };
41507     } catch (...) {
41508       {
41509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41510       };
41511     }
41512   }
41513
41514   jresult = (void *)result;
41515   return jresult;
41516 }
41517
41518
41519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41520   void * jresult ;
41521   Dali::PinchGesture *arg1 = 0 ;
41522   Dali::PinchGesture *result = 0 ;
41523
41524   arg1 = (Dali::PinchGesture *)jarg1;
41525   if (!arg1) {
41526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41527     return 0;
41528   }
41529   {
41530     try {
41531       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41532     } catch (std::out_of_range& e) {
41533       {
41534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41535       };
41536     } catch (std::exception& e) {
41537       {
41538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (Dali::DaliException e) {
41541       {
41542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41543       };
41544     } catch (...) {
41545       {
41546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41547       };
41548     }
41549   }
41550
41551   jresult = (void *)result;
41552   return jresult;
41553 }
41554
41555
41556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41557   void * jresult ;
41558   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41559   Dali::PinchGesture *arg2 = 0 ;
41560   Dali::PinchGesture *result = 0 ;
41561
41562   arg1 = (Dali::PinchGesture *)jarg1;
41563   arg2 = (Dali::PinchGesture *)jarg2;
41564   if (!arg2) {
41565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41566     return 0;
41567   }
41568   {
41569     try {
41570       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41571     } catch (std::out_of_range& e) {
41572       {
41573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41574       };
41575     } catch (std::exception& e) {
41576       {
41577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41578       };
41579     } catch (Dali::DaliException e) {
41580       {
41581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41582       };
41583     } catch (...) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41586       };
41587     }
41588   }
41589
41590   jresult = (void *)result;
41591   return jresult;
41592 }
41593
41594
41595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41596   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41597
41598   arg1 = (Dali::PinchGesture *)jarg1;
41599   {
41600     try {
41601       delete arg1;
41602     } catch (std::out_of_range& e) {
41603       {
41604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41605       };
41606     } catch (std::exception& e) {
41607       {
41608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41609       };
41610     } catch (Dali::DaliException e) {
41611       {
41612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41613       };
41614     } catch (...) {
41615       {
41616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41617       };
41618     }
41619   }
41620
41621 }
41622
41623
41624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41625   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41626   float arg2 ;
41627
41628   arg1 = (Dali::PinchGesture *)jarg1;
41629   arg2 = (float)jarg2;
41630   if (arg1) (arg1)->scale = arg2;
41631 }
41632
41633
41634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41635   float jresult ;
41636   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41637   float result;
41638
41639   arg1 = (Dali::PinchGesture *)jarg1;
41640   result = (float) ((arg1)->scale);
41641   jresult = result;
41642   return jresult;
41643 }
41644
41645
41646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41647   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41648   float arg2 ;
41649
41650   arg1 = (Dali::PinchGesture *)jarg1;
41651   arg2 = (float)jarg2;
41652   if (arg1) (arg1)->speed = arg2;
41653 }
41654
41655
41656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41657   float jresult ;
41658   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41659   float result;
41660
41661   arg1 = (Dali::PinchGesture *)jarg1;
41662   result = (float) ((arg1)->speed);
41663   jresult = result;
41664   return jresult;
41665 }
41666
41667
41668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41669   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41670   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41671
41672   arg1 = (Dali::PinchGesture *)jarg1;
41673   arg2 = (Dali::Vector2 *)jarg2;
41674   if (arg1) (arg1)->screenCenterPoint = *arg2;
41675 }
41676
41677
41678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41679   void * jresult ;
41680   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41681   Dali::Vector2 *result = 0 ;
41682
41683   arg1 = (Dali::PinchGesture *)jarg1;
41684   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41685   jresult = (void *)result;
41686   return jresult;
41687 }
41688
41689
41690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41691   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41692   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41693
41694   arg1 = (Dali::PinchGesture *)jarg1;
41695   arg2 = (Dali::Vector2 *)jarg2;
41696   if (arg1) (arg1)->localCenterPoint = *arg2;
41697 }
41698
41699
41700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41701   void * jresult ;
41702   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41703   Dali::Vector2 *result = 0 ;
41704
41705   arg1 = (Dali::PinchGesture *)jarg1;
41706   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41707   jresult = (void *)result;
41708   return jresult;
41709 }
41710
41711
41712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41713   void * jresult ;
41714   Dali::TapGestureDetector *result = 0 ;
41715
41716   {
41717     try {
41718       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41719     } catch (std::out_of_range& e) {
41720       {
41721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41722       };
41723     } catch (std::exception& e) {
41724       {
41725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41726       };
41727     } catch (Dali::DaliException e) {
41728       {
41729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41730       };
41731     } catch (...) {
41732       {
41733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41734       };
41735     }
41736   }
41737
41738   jresult = (void *)result;
41739   return jresult;
41740 }
41741
41742
41743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41744   void * jresult ;
41745   Dali::TapGestureDetector result;
41746
41747   {
41748     try {
41749       result = Dali::TapGestureDetector::New();
41750     } catch (std::out_of_range& e) {
41751       {
41752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41753       };
41754     } catch (std::exception& e) {
41755       {
41756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (Dali::DaliException e) {
41759       {
41760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768
41769   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41770   return jresult;
41771 }
41772
41773
41774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41775   void * jresult ;
41776   unsigned int arg1 ;
41777   Dali::TapGestureDetector result;
41778
41779   arg1 = (unsigned int)jarg1;
41780   {
41781     try {
41782       result = Dali::TapGestureDetector::New(arg1);
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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41808   void * jresult ;
41809   Dali::BaseHandle arg1 ;
41810   Dali::BaseHandle *argp1 ;
41811   Dali::TapGestureDetector result;
41812
41813   argp1 = (Dali::BaseHandle *)jarg1;
41814   if (!argp1) {
41815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41816     return 0;
41817   }
41818   arg1 = *argp1;
41819   {
41820     try {
41821       result = Dali::TapGestureDetector::DownCast(arg1);
41822     } catch (std::out_of_range& e) {
41823       {
41824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41825       };
41826     } catch (std::exception& e) {
41827       {
41828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41829       };
41830     } catch (Dali::DaliException e) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41833       };
41834     } catch (...) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41837       };
41838     }
41839   }
41840
41841   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41847   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41848
41849   arg1 = (Dali::TapGestureDetector *)jarg1;
41850   {
41851     try {
41852       delete arg1;
41853     } catch (std::out_of_range& e) {
41854       {
41855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41856       };
41857     } catch (std::exception& e) {
41858       {
41859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41860       };
41861     } catch (Dali::DaliException e) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41864       };
41865     } catch (...) {
41866       {
41867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41868       };
41869     }
41870   }
41871
41872 }
41873
41874
41875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41876   void * jresult ;
41877   Dali::TapGestureDetector *arg1 = 0 ;
41878   Dali::TapGestureDetector *result = 0 ;
41879
41880   arg1 = (Dali::TapGestureDetector *)jarg1;
41881   if (!arg1) {
41882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41883     return 0;
41884   }
41885   {
41886     try {
41887       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41888     } catch (std::out_of_range& e) {
41889       {
41890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41891       };
41892     } catch (std::exception& e) {
41893       {
41894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41895       };
41896     } catch (Dali::DaliException e) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41899       };
41900     } catch (...) {
41901       {
41902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41903       };
41904     }
41905   }
41906
41907   jresult = (void *)result;
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41913   void * jresult ;
41914   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41915   Dali::TapGestureDetector *arg2 = 0 ;
41916   Dali::TapGestureDetector *result = 0 ;
41917
41918   arg1 = (Dali::TapGestureDetector *)jarg1;
41919   arg2 = (Dali::TapGestureDetector *)jarg2;
41920   if (!arg2) {
41921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41922     return 0;
41923   }
41924   {
41925     try {
41926       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41927     } catch (std::out_of_range& e) {
41928       {
41929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41930       };
41931     } catch (std::exception& e) {
41932       {
41933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41934       };
41935     } catch (Dali::DaliException e) {
41936       {
41937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41938       };
41939     } catch (...) {
41940       {
41941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41942       };
41943     }
41944   }
41945
41946   jresult = (void *)result;
41947   return jresult;
41948 }
41949
41950
41951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41952   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41953   unsigned int arg2 ;
41954
41955   arg1 = (Dali::TapGestureDetector *)jarg1;
41956   arg2 = (unsigned int)jarg2;
41957   {
41958     try {
41959       (arg1)->SetMinimumTapsRequired(arg2);
41960     } catch (std::out_of_range& e) {
41961       {
41962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41963       };
41964     } catch (std::exception& e) {
41965       {
41966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41967       };
41968     } catch (Dali::DaliException e) {
41969       {
41970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41971       };
41972     } catch (...) {
41973       {
41974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41975       };
41976     }
41977   }
41978
41979 }
41980
41981
41982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41983   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41984   unsigned int arg2 ;
41985
41986   arg1 = (Dali::TapGestureDetector *)jarg1;
41987   arg2 = (unsigned int)jarg2;
41988   {
41989     try {
41990       (arg1)->SetMaximumTapsRequired(arg2);
41991     } catch (std::out_of_range& e) {
41992       {
41993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41994       };
41995     } catch (std::exception& e) {
41996       {
41997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41998       };
41999     } catch (Dali::DaliException e) {
42000       {
42001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42002       };
42003     } catch (...) {
42004       {
42005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42006       };
42007     }
42008   }
42009
42010 }
42011
42012
42013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42014   unsigned int jresult ;
42015   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42016   unsigned int result;
42017
42018   arg1 = (Dali::TapGestureDetector *)jarg1;
42019   {
42020     try {
42021       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (Dali::DaliException e) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040
42041   jresult = result;
42042   return jresult;
42043 }
42044
42045
42046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42047   unsigned int jresult ;
42048   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42049   unsigned int result;
42050
42051   arg1 = (Dali::TapGestureDetector *)jarg1;
42052   {
42053     try {
42054       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42055     } catch (std::out_of_range& e) {
42056       {
42057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42058       };
42059     } catch (std::exception& e) {
42060       {
42061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42062       };
42063     } catch (Dali::DaliException e) {
42064       {
42065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42066       };
42067     } catch (...) {
42068       {
42069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42070       };
42071     }
42072   }
42073
42074   jresult = result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42080   void * jresult ;
42081   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42082   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42083
42084   arg1 = (Dali::TapGestureDetector *)jarg1;
42085   {
42086     try {
42087       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42088     } catch (std::out_of_range& e) {
42089       {
42090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42091       };
42092     } catch (std::exception& e) {
42093       {
42094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42095       };
42096     } catch (Dali::DaliException e) {
42097       {
42098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42099       };
42100     } catch (...) {
42101       {
42102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42103       };
42104     }
42105   }
42106
42107   jresult = (void *)result;
42108   return jresult;
42109 }
42110
42111
42112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42113   void * jresult ;
42114   Dali::TapGesture *result = 0 ;
42115
42116   {
42117     try {
42118       result = (Dali::TapGesture *)new Dali::TapGesture();
42119     } catch (std::out_of_range& e) {
42120       {
42121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42122       };
42123     } catch (std::exception& e) {
42124       {
42125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42126       };
42127     } catch (Dali::DaliException e) {
42128       {
42129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42130       };
42131     } catch (...) {
42132       {
42133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42134       };
42135     }
42136   }
42137
42138   jresult = (void *)result;
42139   return jresult;
42140 }
42141
42142
42143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42144   void * jresult ;
42145   Dali::TapGesture *arg1 = 0 ;
42146   Dali::TapGesture *result = 0 ;
42147
42148   arg1 = (Dali::TapGesture *)jarg1;
42149   if (!arg1) {
42150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42151     return 0;
42152   }
42153   {
42154     try {
42155       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42156     } catch (std::out_of_range& e) {
42157       {
42158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42159       };
42160     } catch (std::exception& e) {
42161       {
42162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42163       };
42164     } catch (Dali::DaliException e) {
42165       {
42166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42167       };
42168     } catch (...) {
42169       {
42170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42171       };
42172     }
42173   }
42174
42175   jresult = (void *)result;
42176   return jresult;
42177 }
42178
42179
42180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42181   void * jresult ;
42182   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42183   Dali::TapGesture *arg2 = 0 ;
42184   Dali::TapGesture *result = 0 ;
42185
42186   arg1 = (Dali::TapGesture *)jarg1;
42187   arg2 = (Dali::TapGesture *)jarg2;
42188   if (!arg2) {
42189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42190     return 0;
42191   }
42192   {
42193     try {
42194       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42195     } catch (std::out_of_range& e) {
42196       {
42197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42198       };
42199     } catch (std::exception& e) {
42200       {
42201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42202       };
42203     } catch (Dali::DaliException e) {
42204       {
42205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42206       };
42207     } catch (...) {
42208       {
42209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42210       };
42211     }
42212   }
42213
42214   jresult = (void *)result;
42215   return jresult;
42216 }
42217
42218
42219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42220   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42221
42222   arg1 = (Dali::TapGesture *)jarg1;
42223   {
42224     try {
42225       delete arg1;
42226     } catch (std::out_of_range& e) {
42227       {
42228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42229       };
42230     } catch (std::exception& e) {
42231       {
42232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42233       };
42234     } catch (Dali::DaliException e) {
42235       {
42236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42237       };
42238     } catch (...) {
42239       {
42240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42241       };
42242     }
42243   }
42244
42245 }
42246
42247
42248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42249   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42250   unsigned int arg2 ;
42251
42252   arg1 = (Dali::TapGesture *)jarg1;
42253   arg2 = (unsigned int)jarg2;
42254   if (arg1) (arg1)->numberOfTaps = arg2;
42255 }
42256
42257
42258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42259   unsigned int jresult ;
42260   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42261   unsigned int result;
42262
42263   arg1 = (Dali::TapGesture *)jarg1;
42264   result = (unsigned int) ((arg1)->numberOfTaps);
42265   jresult = result;
42266   return jresult;
42267 }
42268
42269
42270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42271   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42272   unsigned int arg2 ;
42273
42274   arg1 = (Dali::TapGesture *)jarg1;
42275   arg2 = (unsigned int)jarg2;
42276   if (arg1) (arg1)->numberOfTouches = arg2;
42277 }
42278
42279
42280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42281   unsigned int jresult ;
42282   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42283   unsigned int result;
42284
42285   arg1 = (Dali::TapGesture *)jarg1;
42286   result = (unsigned int) ((arg1)->numberOfTouches);
42287   jresult = result;
42288   return jresult;
42289 }
42290
42291
42292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42293   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42294   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42295
42296   arg1 = (Dali::TapGesture *)jarg1;
42297   arg2 = (Dali::Vector2 *)jarg2;
42298   if (arg1) (arg1)->screenPoint = *arg2;
42299 }
42300
42301
42302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42303   void * jresult ;
42304   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42305   Dali::Vector2 *result = 0 ;
42306
42307   arg1 = (Dali::TapGesture *)jarg1;
42308   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42309   jresult = (void *)result;
42310   return jresult;
42311 }
42312
42313
42314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42315   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42316   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42317
42318   arg1 = (Dali::TapGesture *)jarg1;
42319   arg2 = (Dali::Vector2 *)jarg2;
42320   if (arg1) (arg1)->localPoint = *arg2;
42321 }
42322
42323
42324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42325   void * jresult ;
42326   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42327   Dali::Vector2 *result = 0 ;
42328
42329   arg1 = (Dali::TapGesture *)jarg1;
42330   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42331   jresult = (void *)result;
42332   return jresult;
42333 }
42334
42335
42336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42337   void * jresult ;
42338   Dali::AlphaFunction *result = 0 ;
42339
42340   {
42341     try {
42342       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (Dali::DaliException e) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42354       };
42355     } catch (...) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42358       };
42359     }
42360   }
42361
42362   jresult = (void *)result;
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42368   void * jresult ;
42369   Dali::AlphaFunction::BuiltinFunction arg1 ;
42370   Dali::AlphaFunction *result = 0 ;
42371
42372   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42373   {
42374     try {
42375       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42376     } catch (std::out_of_range& e) {
42377       {
42378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42379       };
42380     } catch (std::exception& e) {
42381       {
42382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42383       };
42384     } catch (Dali::DaliException e) {
42385       {
42386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42391       };
42392     }
42393   }
42394
42395   jresult = (void *)result;
42396   return jresult;
42397 }
42398
42399
42400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42401   void * jresult ;
42402   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42403   Dali::AlphaFunction *result = 0 ;
42404
42405   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42406   {
42407     try {
42408       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42409     } catch (std::out_of_range& e) {
42410       {
42411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (std::exception& e) {
42414       {
42415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (Dali::DaliException e) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42420       };
42421     } catch (...) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42424       };
42425     }
42426   }
42427
42428   jresult = (void *)result;
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42434   void * jresult ;
42435   Dali::Vector2 *arg1 = 0 ;
42436   Dali::Vector2 *arg2 = 0 ;
42437   Dali::AlphaFunction *result = 0 ;
42438
42439   arg1 = (Dali::Vector2 *)jarg1;
42440   if (!arg1) {
42441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42442     return 0;
42443   }
42444   arg2 = (Dali::Vector2 *)jarg2;
42445   if (!arg2) {
42446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42447     return 0;
42448   }
42449   {
42450     try {
42451       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42452     } catch (std::out_of_range& e) {
42453       {
42454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42455       };
42456     } catch (std::exception& e) {
42457       {
42458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42459       };
42460     } catch (Dali::DaliException e) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42463       };
42464     } catch (...) {
42465       {
42466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42467       };
42468     }
42469   }
42470
42471   jresult = (void *)result;
42472   return jresult;
42473 }
42474
42475
42476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42477   void * jresult ;
42478   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42479   Dali::Vector4 result;
42480
42481   arg1 = (Dali::AlphaFunction *)jarg1;
42482   {
42483     try {
42484       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42485     } catch (std::out_of_range& e) {
42486       {
42487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42488       };
42489     } catch (std::exception& e) {
42490       {
42491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42492       };
42493     } catch (Dali::DaliException e) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42496       };
42497     } catch (...) {
42498       {
42499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42500       };
42501     }
42502   }
42503
42504   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42505   return jresult;
42506 }
42507
42508
42509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42510   void * jresult ;
42511   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42512   Dali::AlphaFunctionPrototype result;
42513
42514   arg1 = (Dali::AlphaFunction *)jarg1;
42515   {
42516     try {
42517       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42518     } catch (std::out_of_range& e) {
42519       {
42520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42521       };
42522     } catch (std::exception& e) {
42523       {
42524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42525       };
42526     } catch (Dali::DaliException e) {
42527       {
42528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42529       };
42530     } catch (...) {
42531       {
42532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42533       };
42534     }
42535   }
42536
42537   jresult = (void *)result;
42538   return jresult;
42539 }
42540
42541
42542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42543   int jresult ;
42544   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42545   Dali::AlphaFunction::BuiltinFunction result;
42546
42547   arg1 = (Dali::AlphaFunction *)jarg1;
42548   {
42549     try {
42550       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42551     } catch (std::out_of_range& e) {
42552       {
42553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42554       };
42555     } catch (std::exception& e) {
42556       {
42557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42558       };
42559     } catch (Dali::DaliException e) {
42560       {
42561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42562       };
42563     } catch (...) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42566       };
42567     }
42568   }
42569
42570   jresult = (int)result;
42571   return jresult;
42572 }
42573
42574
42575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42576   int jresult ;
42577   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42578   Dali::AlphaFunction::Mode result;
42579
42580   arg1 = (Dali::AlphaFunction *)jarg1;
42581   {
42582     try {
42583       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42584     } catch (std::out_of_range& e) {
42585       {
42586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42587       };
42588     } catch (std::exception& e) {
42589       {
42590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42591       };
42592     } catch (Dali::DaliException e) {
42593       {
42594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42595       };
42596     } catch (...) {
42597       {
42598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42599       };
42600     }
42601   }
42602
42603   jresult = (int)result;
42604   return jresult;
42605 }
42606
42607
42608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42609   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42610
42611   arg1 = (Dali::AlphaFunction *)jarg1;
42612   {
42613     try {
42614       delete arg1;
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42622       };
42623     } catch (Dali::DaliException e) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42626       };
42627     } catch (...) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42630       };
42631     }
42632   }
42633
42634 }
42635
42636
42637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42638   void * jresult ;
42639   Dali::KeyFrames result;
42640
42641   {
42642     try {
42643       result = Dali::KeyFrames::New();
42644     } catch (std::out_of_range& e) {
42645       {
42646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42647       };
42648     } catch (std::exception& e) {
42649       {
42650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (Dali::DaliException e) {
42653       {
42654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42655       };
42656     } catch (...) {
42657       {
42658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42659       };
42660     }
42661   }
42662
42663   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42664   return jresult;
42665 }
42666
42667
42668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42669   void * jresult ;
42670   Dali::BaseHandle arg1 ;
42671   Dali::BaseHandle *argp1 ;
42672   Dali::KeyFrames result;
42673
42674   argp1 = (Dali::BaseHandle *)jarg1;
42675   if (!argp1) {
42676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42677     return 0;
42678   }
42679   arg1 = *argp1;
42680   {
42681     try {
42682       result = Dali::KeyFrames::DownCast(arg1);
42683     } catch (std::out_of_range& e) {
42684       {
42685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42686       };
42687     } catch (std::exception& e) {
42688       {
42689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42690       };
42691     } catch (Dali::DaliException e) {
42692       {
42693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42694       };
42695     } catch (...) {
42696       {
42697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42698       };
42699     }
42700   }
42701
42702   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42703   return jresult;
42704 }
42705
42706
42707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42708   void * jresult ;
42709   Dali::KeyFrames *result = 0 ;
42710
42711   {
42712     try {
42713       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42714     } catch (std::out_of_range& e) {
42715       {
42716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (std::exception& e) {
42719       {
42720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42721       };
42722     } catch (Dali::DaliException e) {
42723       {
42724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42725       };
42726     } catch (...) {
42727       {
42728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42729       };
42730     }
42731   }
42732
42733   jresult = (void *)result;
42734   return jresult;
42735 }
42736
42737
42738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42739   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42740
42741   arg1 = (Dali::KeyFrames *)jarg1;
42742   {
42743     try {
42744       delete arg1;
42745     } catch (std::out_of_range& e) {
42746       {
42747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42748       };
42749     } catch (std::exception& e) {
42750       {
42751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42752       };
42753     } catch (Dali::DaliException e) {
42754       {
42755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42756       };
42757     } catch (...) {
42758       {
42759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42760       };
42761     }
42762   }
42763
42764 }
42765
42766
42767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42768   void * jresult ;
42769   Dali::KeyFrames *arg1 = 0 ;
42770   Dali::KeyFrames *result = 0 ;
42771
42772   arg1 = (Dali::KeyFrames *)jarg1;
42773   if (!arg1) {
42774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42775     return 0;
42776   }
42777   {
42778     try {
42779       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42780     } catch (std::out_of_range& e) {
42781       {
42782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (std::exception& e) {
42785       {
42786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42787       };
42788     } catch (Dali::DaliException e) {
42789       {
42790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42791       };
42792     } catch (...) {
42793       {
42794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42795       };
42796     }
42797   }
42798
42799   jresult = (void *)result;
42800   return jresult;
42801 }
42802
42803
42804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42805   void * jresult ;
42806   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42807   Dali::KeyFrames *arg2 = 0 ;
42808   Dali::KeyFrames *result = 0 ;
42809
42810   arg1 = (Dali::KeyFrames *)jarg1;
42811   arg2 = (Dali::KeyFrames *)jarg2;
42812   if (!arg2) {
42813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42814     return 0;
42815   }
42816   {
42817     try {
42818       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42819     } catch (std::out_of_range& e) {
42820       {
42821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42822       };
42823     } catch (std::exception& e) {
42824       {
42825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42826       };
42827     } catch (Dali::DaliException e) {
42828       {
42829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42830       };
42831     } catch (...) {
42832       {
42833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42834       };
42835     }
42836   }
42837
42838   jresult = (void *)result;
42839   return jresult;
42840 }
42841
42842
42843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42844   int jresult ;
42845   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42846   Dali::Property::Type result;
42847
42848   arg1 = (Dali::KeyFrames *)jarg1;
42849   {
42850     try {
42851       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42852     } catch (std::out_of_range& e) {
42853       {
42854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (std::exception& e) {
42857       {
42858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42859       };
42860     } catch (Dali::DaliException e) {
42861       {
42862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42863       };
42864     } catch (...) {
42865       {
42866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42867       };
42868     }
42869   }
42870
42871   jresult = (int)result;
42872   return jresult;
42873 }
42874
42875
42876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42877   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42878   float arg2 ;
42879   Dali::Property::Value arg3 ;
42880   Dali::Property::Value *argp3 ;
42881
42882   arg1 = (Dali::KeyFrames *)jarg1;
42883   arg2 = (float)jarg2;
42884   argp3 = (Dali::Property::Value *)jarg3;
42885   if (!argp3) {
42886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42887     return ;
42888   }
42889   arg3 = *argp3;
42890   {
42891     try {
42892       (arg1)->Add(arg2,arg3);
42893     } catch (std::out_of_range& e) {
42894       {
42895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42896       };
42897     } catch (std::exception& e) {
42898       {
42899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42900       };
42901     } catch (Dali::DaliException e) {
42902       {
42903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42904       };
42905     } catch (...) {
42906       {
42907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42908       };
42909     }
42910   }
42911
42912 }
42913
42914
42915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42916   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42917   float arg2 ;
42918   Dali::Property::Value arg3 ;
42919   Dali::AlphaFunction arg4 ;
42920   Dali::Property::Value *argp3 ;
42921   Dali::AlphaFunction *argp4 ;
42922
42923   arg1 = (Dali::KeyFrames *)jarg1;
42924   arg2 = (float)jarg2;
42925   argp3 = (Dali::Property::Value *)jarg3;
42926   if (!argp3) {
42927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42928     return ;
42929   }
42930   arg3 = *argp3;
42931   argp4 = (Dali::AlphaFunction *)jarg4;
42932   if (!argp4) {
42933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42934     return ;
42935   }
42936   arg4 = *argp4;
42937   {
42938     try {
42939       (arg1)->Add(arg2,arg3,arg4);
42940     } catch (std::out_of_range& e) {
42941       {
42942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42943       };
42944     } catch (std::exception& e) {
42945       {
42946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42947       };
42948     } catch (Dali::DaliException e) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42951       };
42952     } catch (...) {
42953       {
42954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42955       };
42956     }
42957   }
42958
42959 }
42960
42961
42962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42963   int jresult ;
42964   int result;
42965
42966   result = (int)Dali::Path::Property::POINTS;
42967   jresult = (int)result;
42968   return jresult;
42969 }
42970
42971
42972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42973   int jresult ;
42974   int result;
42975
42976   result = (int)Dali::Path::Property::CONTROL_POINTS;
42977   jresult = (int)result;
42978   return jresult;
42979 }
42980
42981
42982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42983   void * jresult ;
42984   Dali::Path::Property *result = 0 ;
42985
42986   {
42987     try {
42988       result = (Dali::Path::Property *)new Dali::Path::Property();
42989     } catch (std::out_of_range& e) {
42990       {
42991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42992       };
42993     } catch (std::exception& e) {
42994       {
42995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42996       };
42997     } catch (Dali::DaliException e) {
42998       {
42999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43000       };
43001     } catch (...) {
43002       {
43003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43004       };
43005     }
43006   }
43007
43008   jresult = (void *)result;
43009   return jresult;
43010 }
43011
43012
43013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43014   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43015
43016   arg1 = (Dali::Path::Property *)jarg1;
43017   {
43018     try {
43019       delete arg1;
43020     } catch (std::out_of_range& e) {
43021       {
43022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43023       };
43024     } catch (std::exception& e) {
43025       {
43026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43027       };
43028     } catch (Dali::DaliException e) {
43029       {
43030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43031       };
43032     } catch (...) {
43033       {
43034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43035       };
43036     }
43037   }
43038
43039 }
43040
43041
43042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43043   void * jresult ;
43044   Dali::Path result;
43045
43046   {
43047     try {
43048       result = Dali::Path::New();
43049     } catch (std::out_of_range& e) {
43050       {
43051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43052       };
43053     } catch (std::exception& e) {
43054       {
43055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43056       };
43057     } catch (Dali::DaliException e) {
43058       {
43059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43060       };
43061     } catch (...) {
43062       {
43063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43064       };
43065     }
43066   }
43067
43068   jresult = new Dali::Path((const Dali::Path &)result);
43069   return jresult;
43070 }
43071
43072
43073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43074   void * jresult ;
43075   Dali::BaseHandle arg1 ;
43076   Dali::BaseHandle *argp1 ;
43077   Dali::Path result;
43078
43079   argp1 = (Dali::BaseHandle *)jarg1;
43080   if (!argp1) {
43081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43082     return 0;
43083   }
43084   arg1 = *argp1;
43085   {
43086     try {
43087       result = Dali::Path::DownCast(arg1);
43088     } catch (std::out_of_range& e) {
43089       {
43090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43091       };
43092     } catch (std::exception& e) {
43093       {
43094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43095       };
43096     } catch (Dali::DaliException e) {
43097       {
43098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43099       };
43100     } catch (...) {
43101       {
43102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43103       };
43104     }
43105   }
43106
43107   jresult = new Dali::Path((const Dali::Path &)result);
43108   return jresult;
43109 }
43110
43111
43112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43113   void * jresult ;
43114   Dali::Path *result = 0 ;
43115
43116   {
43117     try {
43118       result = (Dali::Path *)new Dali::Path();
43119     } catch (std::out_of_range& e) {
43120       {
43121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43122       };
43123     } catch (std::exception& e) {
43124       {
43125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43126       };
43127     } catch (Dali::DaliException e) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43130       };
43131     } catch (...) {
43132       {
43133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43134       };
43135     }
43136   }
43137
43138   jresult = (void *)result;
43139   return jresult;
43140 }
43141
43142
43143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43144   Dali::Path *arg1 = (Dali::Path *) 0 ;
43145
43146   arg1 = (Dali::Path *)jarg1;
43147   {
43148     try {
43149       delete arg1;
43150     } catch (std::out_of_range& e) {
43151       {
43152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43153       };
43154     } catch (std::exception& e) {
43155       {
43156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43157       };
43158     } catch (Dali::DaliException e) {
43159       {
43160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43161       };
43162     } catch (...) {
43163       {
43164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43165       };
43166     }
43167   }
43168
43169 }
43170
43171
43172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43173   void * jresult ;
43174   Dali::Path *arg1 = 0 ;
43175   Dali::Path *result = 0 ;
43176
43177   arg1 = (Dali::Path *)jarg1;
43178   if (!arg1) {
43179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43180     return 0;
43181   }
43182   {
43183     try {
43184       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (Dali::DaliException e) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43200       };
43201     }
43202   }
43203
43204   jresult = (void *)result;
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43210   void * jresult ;
43211   Dali::Path *arg1 = (Dali::Path *) 0 ;
43212   Dali::Path *arg2 = 0 ;
43213   Dali::Path *result = 0 ;
43214
43215   arg1 = (Dali::Path *)jarg1;
43216   arg2 = (Dali::Path *)jarg2;
43217   if (!arg2) {
43218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43219     return 0;
43220   }
43221   {
43222     try {
43223       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43224     } catch (std::out_of_range& e) {
43225       {
43226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43227       };
43228     } catch (std::exception& e) {
43229       {
43230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43231       };
43232     } catch (Dali::DaliException e) {
43233       {
43234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43235       };
43236     } catch (...) {
43237       {
43238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43239       };
43240     }
43241   }
43242
43243   jresult = (void *)result;
43244   return jresult;
43245 }
43246
43247
43248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43249   Dali::Path *arg1 = (Dali::Path *) 0 ;
43250   Dali::Vector3 *arg2 = 0 ;
43251
43252   arg1 = (Dali::Path *)jarg1;
43253   arg2 = (Dali::Vector3 *)jarg2;
43254   if (!arg2) {
43255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43256     return ;
43257   }
43258   {
43259     try {
43260       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43261     } catch (std::out_of_range& e) {
43262       {
43263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43264       };
43265     } catch (std::exception& e) {
43266       {
43267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43268       };
43269     } catch (Dali::DaliException e) {
43270       {
43271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43272       };
43273     } catch (...) {
43274       {
43275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43276       };
43277     }
43278   }
43279
43280 }
43281
43282
43283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43284   Dali::Path *arg1 = (Dali::Path *) 0 ;
43285   Dali::Vector3 *arg2 = 0 ;
43286
43287   arg1 = (Dali::Path *)jarg1;
43288   arg2 = (Dali::Vector3 *)jarg2;
43289   if (!arg2) {
43290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43291     return ;
43292   }
43293   {
43294     try {
43295       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43303       };
43304     } catch (Dali::DaliException e) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43307       };
43308     } catch (...) {
43309       {
43310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43311       };
43312     }
43313   }
43314
43315 }
43316
43317
43318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43319   Dali::Path *arg1 = (Dali::Path *) 0 ;
43320   float arg2 ;
43321
43322   arg1 = (Dali::Path *)jarg1;
43323   arg2 = (float)jarg2;
43324   {
43325     try {
43326       (arg1)->GenerateControlPoints(arg2);
43327     } catch (std::out_of_range& e) {
43328       {
43329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43330       };
43331     } catch (std::exception& e) {
43332       {
43333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43334       };
43335     } catch (Dali::DaliException e) {
43336       {
43337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43338       };
43339     } catch (...) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43342       };
43343     }
43344   }
43345
43346 }
43347
43348
43349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43350   Dali::Path *arg1 = (Dali::Path *) 0 ;
43351   float arg2 ;
43352   Dali::Vector3 *arg3 = 0 ;
43353   Dali::Vector3 *arg4 = 0 ;
43354
43355   arg1 = (Dali::Path *)jarg1;
43356   arg2 = (float)jarg2;
43357   arg3 = (Dali::Vector3 *)jarg3;
43358   if (!arg3) {
43359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43360     return ;
43361   }
43362   arg4 = (Dali::Vector3 *)jarg4;
43363   if (!arg4) {
43364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43365     return ;
43366   }
43367   {
43368     try {
43369       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43370     } catch (std::out_of_range& e) {
43371       {
43372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43373       };
43374     } catch (std::exception& e) {
43375       {
43376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43377       };
43378     } catch (Dali::DaliException e) {
43379       {
43380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43381       };
43382     } catch (...) {
43383       {
43384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43385       };
43386     }
43387   }
43388
43389 }
43390
43391
43392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43393   void * jresult ;
43394   Dali::Path *arg1 = (Dali::Path *) 0 ;
43395   size_t arg2 ;
43396   Dali::Vector3 *result = 0 ;
43397
43398   arg1 = (Dali::Path *)jarg1;
43399   arg2 = (size_t)jarg2;
43400   {
43401     try {
43402       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43403     } catch (std::out_of_range& e) {
43404       {
43405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43406       };
43407     } catch (std::exception& e) {
43408       {
43409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (Dali::DaliException e) {
43412       {
43413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421
43422   jresult = (void *)result;
43423   return jresult;
43424 }
43425
43426
43427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43428   void * jresult ;
43429   Dali::Path *arg1 = (Dali::Path *) 0 ;
43430   size_t arg2 ;
43431   Dali::Vector3 *result = 0 ;
43432
43433   arg1 = (Dali::Path *)jarg1;
43434   arg2 = (size_t)jarg2;
43435   {
43436     try {
43437       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43438     } catch (std::out_of_range& e) {
43439       {
43440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43441       };
43442     } catch (std::exception& e) {
43443       {
43444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43445       };
43446     } catch (Dali::DaliException e) {
43447       {
43448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43449       };
43450     } catch (...) {
43451       {
43452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43453       };
43454     }
43455   }
43456
43457   jresult = (void *)result;
43458   return jresult;
43459 }
43460
43461
43462 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43463   unsigned long jresult ;
43464   Dali::Path *arg1 = (Dali::Path *) 0 ;
43465   size_t result;
43466
43467   arg1 = (Dali::Path *)jarg1;
43468   {
43469     try {
43470       result = ((Dali::Path const *)arg1)->GetPointCount();
43471     } catch (std::out_of_range& e) {
43472       {
43473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (std::exception& e) {
43476       {
43477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43478       };
43479     } catch (Dali::DaliException e) {
43480       {
43481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43482       };
43483     } catch (...) {
43484       {
43485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43486       };
43487     }
43488   }
43489
43490   jresult = (unsigned long)result;
43491   return jresult;
43492 }
43493
43494
43495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43496   void * jresult ;
43497   float arg1 ;
43498   Dali::TimePeriod *result = 0 ;
43499
43500   arg1 = (float)jarg1;
43501   {
43502     try {
43503       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43504     } catch (std::out_of_range& e) {
43505       {
43506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (std::exception& e) {
43509       {
43510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43511       };
43512     } catch (Dali::DaliException e) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43515       };
43516     } catch (...) {
43517       {
43518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43519       };
43520     }
43521   }
43522
43523   jresult = (void *)result;
43524   return jresult;
43525 }
43526
43527
43528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43529   void * jresult ;
43530   float arg1 ;
43531   float arg2 ;
43532   Dali::TimePeriod *result = 0 ;
43533
43534   arg1 = (float)jarg1;
43535   arg2 = (float)jarg2;
43536   {
43537     try {
43538       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43539     } catch (std::out_of_range& e) {
43540       {
43541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43542       };
43543     } catch (std::exception& e) {
43544       {
43545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43546       };
43547     } catch (Dali::DaliException e) {
43548       {
43549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43550       };
43551     } catch (...) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43554       };
43555     }
43556   }
43557
43558   jresult = (void *)result;
43559   return jresult;
43560 }
43561
43562
43563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43564   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43565
43566   arg1 = (Dali::TimePeriod *)jarg1;
43567   {
43568     try {
43569       delete arg1;
43570     } catch (std::out_of_range& e) {
43571       {
43572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43573       };
43574     } catch (std::exception& e) {
43575       {
43576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43577       };
43578     } catch (Dali::DaliException e) {
43579       {
43580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43581       };
43582     } catch (...) {
43583       {
43584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43585       };
43586     }
43587   }
43588
43589 }
43590
43591
43592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43593   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43594   float arg2 ;
43595
43596   arg1 = (Dali::TimePeriod *)jarg1;
43597   arg2 = (float)jarg2;
43598   if (arg1) (arg1)->delaySeconds = arg2;
43599 }
43600
43601
43602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43603   float jresult ;
43604   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43605   float result;
43606
43607   arg1 = (Dali::TimePeriod *)jarg1;
43608   result = (float) ((arg1)->delaySeconds);
43609   jresult = result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43615   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43616   float arg2 ;
43617
43618   arg1 = (Dali::TimePeriod *)jarg1;
43619   arg2 = (float)jarg2;
43620   if (arg1) (arg1)->durationSeconds = arg2;
43621 }
43622
43623
43624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43625   float jresult ;
43626   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43627   float result;
43628
43629   arg1 = (Dali::TimePeriod *)jarg1;
43630   result = (float) ((arg1)->durationSeconds);
43631   jresult = result;
43632   return jresult;
43633 }
43634
43635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43636   int jresult ;
43637   int result;
43638
43639   result = (int)Dali::LinearConstrainer::Property::VALUE;
43640   jresult = (int)result;
43641   return jresult;
43642 }
43643
43644
43645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43646   int jresult ;
43647   int result;
43648
43649   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43650   jresult = (int)result;
43651   return jresult;
43652 }
43653
43654
43655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43656   void * jresult ;
43657   Dali::LinearConstrainer::Property *result = 0 ;
43658
43659   {
43660     try {
43661       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43662     } catch (std::out_of_range& e) {
43663       {
43664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43665       };
43666     } catch (std::exception& e) {
43667       {
43668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43669       };
43670     } catch (Dali::DaliException e) {
43671       {
43672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43673       };
43674     } catch (...) {
43675       {
43676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43677       };
43678     }
43679   }
43680
43681   jresult = (void *)result;
43682   return jresult;
43683 }
43684
43685
43686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43687   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43688
43689   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43690   {
43691     try {
43692       delete arg1;
43693     } catch (std::out_of_range& e) {
43694       {
43695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43696       };
43697     } catch (std::exception& e) {
43698       {
43699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43700       };
43701     } catch (Dali::DaliException e) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43704       };
43705     } catch (...) {
43706       {
43707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43708       };
43709     }
43710   }
43711
43712 }
43713
43714
43715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43716   void * jresult ;
43717   Dali::LinearConstrainer result;
43718
43719   {
43720     try {
43721       result = Dali::LinearConstrainer::New();
43722     } catch (std::out_of_range& e) {
43723       {
43724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43725       };
43726     } catch (std::exception& e) {
43727       {
43728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43729       };
43730     } catch (Dali::DaliException e) {
43731       {
43732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43733       };
43734     } catch (...) {
43735       {
43736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43737       };
43738     }
43739   }
43740
43741   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43742   return jresult;
43743 }
43744
43745
43746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43747   void * jresult ;
43748   Dali::BaseHandle arg1 ;
43749   Dali::BaseHandle *argp1 ;
43750   Dali::LinearConstrainer result;
43751
43752   argp1 = (Dali::BaseHandle *)jarg1;
43753   if (!argp1) {
43754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43755     return 0;
43756   }
43757   arg1 = *argp1;
43758   {
43759     try {
43760       result = Dali::LinearConstrainer::DownCast(arg1);
43761     } catch (std::out_of_range& e) {
43762       {
43763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (std::exception& e) {
43766       {
43767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43768       };
43769     } catch (Dali::DaliException e) {
43770       {
43771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43772       };
43773     } catch (...) {
43774       {
43775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43776       };
43777     }
43778   }
43779
43780   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43781   return jresult;
43782 }
43783
43784
43785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43786   void * jresult ;
43787   Dali::LinearConstrainer *result = 0 ;
43788
43789   {
43790     try {
43791       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43792     } catch (std::out_of_range& e) {
43793       {
43794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43795       };
43796     } catch (std::exception& e) {
43797       {
43798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43799       };
43800     } catch (Dali::DaliException e) {
43801       {
43802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43803       };
43804     } catch (...) {
43805       {
43806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43807       };
43808     }
43809   }
43810
43811   jresult = (void *)result;
43812   return jresult;
43813 }
43814
43815
43816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43817   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43818
43819   arg1 = (Dali::LinearConstrainer *)jarg1;
43820   {
43821     try {
43822       delete arg1;
43823     } catch (std::out_of_range& e) {
43824       {
43825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43826       };
43827     } catch (std::exception& e) {
43828       {
43829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43830       };
43831     } catch (Dali::DaliException e) {
43832       {
43833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43834       };
43835     } catch (...) {
43836       {
43837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43838       };
43839     }
43840   }
43841
43842 }
43843
43844
43845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43846   void * jresult ;
43847   Dali::LinearConstrainer *arg1 = 0 ;
43848   Dali::LinearConstrainer *result = 0 ;
43849
43850   arg1 = (Dali::LinearConstrainer *)jarg1;
43851   if (!arg1) {
43852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43853     return 0;
43854   }
43855   {
43856     try {
43857       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43858     } catch (std::out_of_range& e) {
43859       {
43860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43861       };
43862     } catch (std::exception& e) {
43863       {
43864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43865       };
43866     } catch (Dali::DaliException e) {
43867       {
43868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43869       };
43870     } catch (...) {
43871       {
43872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43873       };
43874     }
43875   }
43876
43877   jresult = (void *)result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43883   void * jresult ;
43884   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43885   Dali::LinearConstrainer *arg2 = 0 ;
43886   Dali::LinearConstrainer *result = 0 ;
43887
43888   arg1 = (Dali::LinearConstrainer *)jarg1;
43889   arg2 = (Dali::LinearConstrainer *)jarg2;
43890   if (!arg2) {
43891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43892     return 0;
43893   }
43894   {
43895     try {
43896       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43897     } catch (std::out_of_range& e) {
43898       {
43899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43900       };
43901     } catch (std::exception& e) {
43902       {
43903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43904       };
43905     } catch (Dali::DaliException e) {
43906       {
43907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43908       };
43909     } catch (...) {
43910       {
43911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43912       };
43913     }
43914   }
43915
43916   jresult = (void *)result;
43917   return jresult;
43918 }
43919
43920
43921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43922   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43923   SwigValueWrapper< Dali::Property > arg2 ;
43924   SwigValueWrapper< Dali::Property > arg3 ;
43925   Dali::Vector2 *arg4 = 0 ;
43926   Dali::Vector2 *arg5 = 0 ;
43927   Dali::Property *argp2 ;
43928   Dali::Property *argp3 ;
43929
43930   arg1 = (Dali::LinearConstrainer *)jarg1;
43931   argp2 = (Dali::Property *)jarg2;
43932   if (!argp2) {
43933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43934     return ;
43935   }
43936   arg2 = *argp2;
43937   argp3 = (Dali::Property *)jarg3;
43938   if (!argp3) {
43939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43940     return ;
43941   }
43942   arg3 = *argp3;
43943   arg4 = (Dali::Vector2 *)jarg4;
43944   if (!arg4) {
43945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43946     return ;
43947   }
43948   arg5 = (Dali::Vector2 *)jarg5;
43949   if (!arg5) {
43950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43951     return ;
43952   }
43953   {
43954     try {
43955       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43956     } catch (std::out_of_range& e) {
43957       {
43958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43959       };
43960     } catch (std::exception& e) {
43961       {
43962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43963       };
43964     } catch (Dali::DaliException e) {
43965       {
43966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43967       };
43968     } catch (...) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43971       };
43972     }
43973   }
43974
43975 }
43976
43977
43978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43979   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43980   SwigValueWrapper< Dali::Property > arg2 ;
43981   SwigValueWrapper< Dali::Property > arg3 ;
43982   Dali::Vector2 *arg4 = 0 ;
43983   Dali::Property *argp2 ;
43984   Dali::Property *argp3 ;
43985
43986   arg1 = (Dali::LinearConstrainer *)jarg1;
43987   argp2 = (Dali::Property *)jarg2;
43988   if (!argp2) {
43989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43990     return ;
43991   }
43992   arg2 = *argp2;
43993   argp3 = (Dali::Property *)jarg3;
43994   if (!argp3) {
43995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43996     return ;
43997   }
43998   arg3 = *argp3;
43999   arg4 = (Dali::Vector2 *)jarg4;
44000   if (!arg4) {
44001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44002     return ;
44003   }
44004   {
44005     try {
44006       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44014       };
44015     } catch (Dali::DaliException e) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44018       };
44019     } catch (...) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44022       };
44023     }
44024   }
44025
44026 }
44027
44028
44029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44030   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44031   Dali::Handle *arg2 = 0 ;
44032
44033   arg1 = (Dali::LinearConstrainer *)jarg1;
44034   arg2 = (Dali::Handle *)jarg2;
44035   if (!arg2) {
44036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44037     return ;
44038   }
44039   {
44040     try {
44041       (arg1)->Remove(*arg2);
44042     } catch (std::out_of_range& e) {
44043       {
44044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44045       };
44046     } catch (std::exception& e) {
44047       {
44048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44049       };
44050     } catch (Dali::DaliException e) {
44051       {
44052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44053       };
44054     } catch (...) {
44055       {
44056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44057       };
44058     }
44059   }
44060
44061 }
44062
44063
44064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44065   int jresult ;
44066   int result;
44067
44068   result = (int)Dali::PathConstrainer::Property::FORWARD;
44069   jresult = (int)result;
44070   return jresult;
44071 }
44072
44073
44074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44075   int jresult ;
44076   int result;
44077
44078   result = (int)Dali::PathConstrainer::Property::POINTS;
44079   jresult = (int)result;
44080   return jresult;
44081 }
44082
44083
44084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44085   int jresult ;
44086   int result;
44087
44088   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44089   jresult = (int)result;
44090   return jresult;
44091 }
44092
44093
44094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44095   void * jresult ;
44096   Dali::PathConstrainer::Property *result = 0 ;
44097
44098   {
44099     try {
44100       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44101     } catch (std::out_of_range& e) {
44102       {
44103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (std::exception& e) {
44106       {
44107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44108       };
44109     } catch (Dali::DaliException e) {
44110       {
44111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44112       };
44113     } catch (...) {
44114       {
44115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44116       };
44117     }
44118   }
44119
44120   jresult = (void *)result;
44121   return jresult;
44122 }
44123
44124
44125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44126   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44127
44128   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44129   {
44130     try {
44131       delete arg1;
44132     } catch (std::out_of_range& e) {
44133       {
44134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44135       };
44136     } catch (std::exception& e) {
44137       {
44138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44139       };
44140     } catch (Dali::DaliException e) {
44141       {
44142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44143       };
44144     } catch (...) {
44145       {
44146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44147       };
44148     }
44149   }
44150
44151 }
44152
44153
44154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44155   void * jresult ;
44156   Dali::PathConstrainer result;
44157
44158   {
44159     try {
44160       result = Dali::PathConstrainer::New();
44161     } catch (std::out_of_range& e) {
44162       {
44163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44164       };
44165     } catch (std::exception& e) {
44166       {
44167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44168       };
44169     } catch (Dali::DaliException e) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44172       };
44173     } catch (...) {
44174       {
44175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44176       };
44177     }
44178   }
44179
44180   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44181   return jresult;
44182 }
44183
44184
44185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44186   void * jresult ;
44187   Dali::BaseHandle arg1 ;
44188   Dali::BaseHandle *argp1 ;
44189   Dali::PathConstrainer result;
44190
44191   argp1 = (Dali::BaseHandle *)jarg1;
44192   if (!argp1) {
44193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44194     return 0;
44195   }
44196   arg1 = *argp1;
44197   {
44198     try {
44199       result = Dali::PathConstrainer::DownCast(arg1);
44200     } catch (std::out_of_range& e) {
44201       {
44202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44203       };
44204     } catch (std::exception& e) {
44205       {
44206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44207       };
44208     } catch (Dali::DaliException e) {
44209       {
44210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44211       };
44212     } catch (...) {
44213       {
44214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44215       };
44216     }
44217   }
44218
44219   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44220   return jresult;
44221 }
44222
44223
44224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44225   void * jresult ;
44226   Dali::PathConstrainer *result = 0 ;
44227
44228   {
44229     try {
44230       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44231     } catch (std::out_of_range& e) {
44232       {
44233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44234       };
44235     } catch (std::exception& e) {
44236       {
44237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44238       };
44239     } catch (Dali::DaliException e) {
44240       {
44241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44242       };
44243     } catch (...) {
44244       {
44245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44246       };
44247     }
44248   }
44249
44250   jresult = (void *)result;
44251   return jresult;
44252 }
44253
44254
44255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44256   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44257
44258   arg1 = (Dali::PathConstrainer *)jarg1;
44259   {
44260     try {
44261       delete arg1;
44262     } catch (std::out_of_range& e) {
44263       {
44264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44265       };
44266     } catch (std::exception& e) {
44267       {
44268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44269       };
44270     } catch (Dali::DaliException e) {
44271       {
44272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44273       };
44274     } catch (...) {
44275       {
44276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44277       };
44278     }
44279   }
44280
44281 }
44282
44283
44284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44285   void * jresult ;
44286   Dali::PathConstrainer *arg1 = 0 ;
44287   Dali::PathConstrainer *result = 0 ;
44288
44289   arg1 = (Dali::PathConstrainer *)jarg1;
44290   if (!arg1) {
44291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44292     return 0;
44293   }
44294   {
44295     try {
44296       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44312       };
44313     }
44314   }
44315
44316   jresult = (void *)result;
44317   return jresult;
44318 }
44319
44320
44321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44322   void * jresult ;
44323   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44324   Dali::PathConstrainer *arg2 = 0 ;
44325   Dali::PathConstrainer *result = 0 ;
44326
44327   arg1 = (Dali::PathConstrainer *)jarg1;
44328   arg2 = (Dali::PathConstrainer *)jarg2;
44329   if (!arg2) {
44330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44331     return 0;
44332   }
44333   {
44334     try {
44335       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44336     } catch (std::out_of_range& e) {
44337       {
44338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44339       };
44340     } catch (std::exception& e) {
44341       {
44342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44343       };
44344     } catch (Dali::DaliException e) {
44345       {
44346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44347       };
44348     } catch (...) {
44349       {
44350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44351       };
44352     }
44353   }
44354
44355   jresult = (void *)result;
44356   return jresult;
44357 }
44358
44359
44360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44361   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44362   SwigValueWrapper< Dali::Property > arg2 ;
44363   SwigValueWrapper< Dali::Property > arg3 ;
44364   Dali::Vector2 *arg4 = 0 ;
44365   Dali::Vector2 *arg5 = 0 ;
44366   Dali::Property *argp2 ;
44367   Dali::Property *argp3 ;
44368
44369   arg1 = (Dali::PathConstrainer *)jarg1;
44370   argp2 = (Dali::Property *)jarg2;
44371   if (!argp2) {
44372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44373     return ;
44374   }
44375   arg2 = *argp2;
44376   argp3 = (Dali::Property *)jarg3;
44377   if (!argp3) {
44378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44379     return ;
44380   }
44381   arg3 = *argp3;
44382   arg4 = (Dali::Vector2 *)jarg4;
44383   if (!arg4) {
44384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44385     return ;
44386   }
44387   arg5 = (Dali::Vector2 *)jarg5;
44388   if (!arg5) {
44389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44390     return ;
44391   }
44392   {
44393     try {
44394       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44395     } catch (std::out_of_range& e) {
44396       {
44397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44398       };
44399     } catch (std::exception& e) {
44400       {
44401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44402       };
44403     } catch (Dali::DaliException e) {
44404       {
44405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44406       };
44407     } catch (...) {
44408       {
44409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44410       };
44411     }
44412   }
44413
44414 }
44415
44416
44417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44418   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44419   SwigValueWrapper< Dali::Property > arg2 ;
44420   SwigValueWrapper< Dali::Property > arg3 ;
44421   Dali::Vector2 *arg4 = 0 ;
44422   Dali::Property *argp2 ;
44423   Dali::Property *argp3 ;
44424
44425   arg1 = (Dali::PathConstrainer *)jarg1;
44426   argp2 = (Dali::Property *)jarg2;
44427   if (!argp2) {
44428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44429     return ;
44430   }
44431   arg2 = *argp2;
44432   argp3 = (Dali::Property *)jarg3;
44433   if (!argp3) {
44434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44435     return ;
44436   }
44437   arg3 = *argp3;
44438   arg4 = (Dali::Vector2 *)jarg4;
44439   if (!arg4) {
44440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44441     return ;
44442   }
44443   {
44444     try {
44445       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44446     } catch (std::out_of_range& e) {
44447       {
44448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44449       };
44450     } catch (std::exception& e) {
44451       {
44452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44453       };
44454     } catch (Dali::DaliException e) {
44455       {
44456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44457       };
44458     } catch (...) {
44459       {
44460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44461       };
44462     }
44463   }
44464
44465 }
44466
44467
44468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44469   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44470   Dali::Handle *arg2 = 0 ;
44471
44472   arg1 = (Dali::PathConstrainer *)jarg1;
44473   arg2 = (Dali::Handle *)jarg2;
44474   if (!arg2) {
44475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44476     return ;
44477   }
44478   {
44479     try {
44480       (arg1)->Remove(*arg2);
44481     } catch (std::out_of_range& e) {
44482       {
44483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44484       };
44485     } catch (std::exception& e) {
44486       {
44487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44488       };
44489     } catch (Dali::DaliException e) {
44490       {
44491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44492       };
44493     } catch (...) {
44494       {
44495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44496       };
44497     }
44498   }
44499
44500 }
44501
44502
44503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44504   int jresult ;
44505   Dali::FittingMode::Type result;
44506
44507   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44508   jresult = (int)result;
44509   return jresult;
44510 }
44511
44512
44513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44514   int jresult ;
44515   Dali::SamplingMode::Type result;
44516
44517   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44518   jresult = (int)result;
44519   return jresult;
44520 }
44521
44522
44523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44524   unsigned int jresult ;
44525   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44526   bool result;
44527
44528   arg1 = (Dali::NativeImageInterface *)jarg1;
44529   {
44530     try {
44531       result = (bool)(arg1)->CreateResource();
44532     } catch (std::out_of_range& e) {
44533       {
44534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44535       };
44536     } catch (std::exception& e) {
44537       {
44538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44539       };
44540     } catch (Dali::DaliException e) {
44541       {
44542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44543       };
44544     } catch (...) {
44545       {
44546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44547       };
44548     }
44549   }
44550
44551   jresult = result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44557   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44558
44559   arg1 = (Dali::NativeImageInterface *)jarg1;
44560   {
44561     try {
44562       (arg1)->DestroyResource();
44563     } catch (std::out_of_range& e) {
44564       {
44565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44566       };
44567     } catch (std::exception& e) {
44568       {
44569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44570       };
44571     } catch (Dali::DaliException e) {
44572       {
44573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44574       };
44575     } catch (...) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44578       };
44579     }
44580   }
44581
44582 }
44583
44584
44585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44586   unsigned int jresult ;
44587   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44588   unsigned int result;
44589
44590   arg1 = (Dali::NativeImageInterface *)jarg1;
44591   {
44592     try {
44593       result = (unsigned int)(arg1)->TargetTexture();
44594     } catch (std::out_of_range& e) {
44595       {
44596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44597       };
44598     } catch (std::exception& e) {
44599       {
44600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44601       };
44602     } catch (Dali::DaliException e) {
44603       {
44604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44605       };
44606     } catch (...) {
44607       {
44608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44609       };
44610     }
44611   }
44612
44613   jresult = result;
44614   return jresult;
44615 }
44616
44617
44618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44619   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44620
44621   arg1 = (Dali::NativeImageInterface *)jarg1;
44622   {
44623     try {
44624       (arg1)->PrepareTexture();
44625     } catch (std::out_of_range& e) {
44626       {
44627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44628       };
44629     } catch (std::exception& e) {
44630       {
44631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44632       };
44633     } catch (Dali::DaliException e) {
44634       {
44635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44636       };
44637     } catch (...) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44640       };
44641     }
44642   }
44643
44644 }
44645
44646
44647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44648   unsigned int jresult ;
44649   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44650   unsigned int result;
44651
44652   arg1 = (Dali::NativeImageInterface *)jarg1;
44653   {
44654     try {
44655       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44656     } catch (std::out_of_range& e) {
44657       {
44658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44659       };
44660     } catch (std::exception& e) {
44661       {
44662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44663       };
44664     } catch (Dali::DaliException e) {
44665       {
44666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44667       };
44668     } catch (...) {
44669       {
44670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44671       };
44672     }
44673   }
44674
44675   jresult = result;
44676   return jresult;
44677 }
44678
44679
44680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44681   unsigned int jresult ;
44682   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44683   unsigned int result;
44684
44685   arg1 = (Dali::NativeImageInterface *)jarg1;
44686   {
44687     try {
44688       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44689     } catch (std::out_of_range& e) {
44690       {
44691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44692       };
44693     } catch (std::exception& e) {
44694       {
44695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44696       };
44697     } catch (Dali::DaliException e) {
44698       {
44699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44700       };
44701     } catch (...) {
44702       {
44703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44704       };
44705     }
44706   }
44707
44708   jresult = result;
44709   return jresult;
44710 }
44711
44712
44713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44714   unsigned int jresult ;
44715   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44716   bool result;
44717
44718   arg1 = (Dali::NativeImageInterface *)jarg1;
44719   {
44720     try {
44721       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44722     } catch (std::out_of_range& e) {
44723       {
44724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44725       };
44726     } catch (std::exception& e) {
44727       {
44728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44729       };
44730     } catch (Dali::DaliException e) {
44731       {
44732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44733       };
44734     } catch (...) {
44735       {
44736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44737       };
44738     }
44739   }
44740
44741   jresult = result;
44742   return jresult;
44743 }
44744
44745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44746   int jresult ;
44747   int result;
44748
44749   result = (int)Dali::CameraActor::Property::TYPE;
44750   jresult = (int)result;
44751   return jresult;
44752 }
44753
44754
44755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44756   int jresult ;
44757   int result;
44758
44759   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44760   jresult = (int)result;
44761   return jresult;
44762 }
44763
44764
44765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44766   int jresult ;
44767   int result;
44768
44769   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44770   jresult = (int)result;
44771   return jresult;
44772 }
44773
44774
44775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44776   int jresult ;
44777   int result;
44778
44779   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44780   jresult = (int)result;
44781   return jresult;
44782 }
44783
44784
44785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44786   int jresult ;
44787   int result;
44788
44789   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44790   jresult = (int)result;
44791   return jresult;
44792 }
44793
44794
44795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44796   int jresult ;
44797   int result;
44798
44799   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44800   jresult = (int)result;
44801   return jresult;
44802 }
44803
44804
44805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44806   int jresult ;
44807   int result;
44808
44809   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44810   jresult = (int)result;
44811   return jresult;
44812 }
44813
44814
44815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44816   int jresult ;
44817   int result;
44818
44819   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44820   jresult = (int)result;
44821   return jresult;
44822 }
44823
44824
44825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44826   int jresult ;
44827   int result;
44828
44829   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44830   jresult = (int)result;
44831   return jresult;
44832 }
44833
44834
44835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44836   int jresult ;
44837   int result;
44838
44839   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44840   jresult = (int)result;
44841   return jresult;
44842 }
44843
44844
44845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44846   int jresult ;
44847   int result;
44848
44849   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44850   jresult = (int)result;
44851   return jresult;
44852 }
44853
44854
44855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44856   int jresult ;
44857   int result;
44858
44859   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44860   jresult = (int)result;
44861   return jresult;
44862 }
44863
44864
44865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44866   int jresult ;
44867   int result;
44868
44869   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44870   jresult = (int)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44876   int jresult ;
44877   int result;
44878
44879   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44880   jresult = (int)result;
44881   return jresult;
44882 }
44883
44884
44885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44886   void * jresult ;
44887   Dali::CameraActor::Property *result = 0 ;
44888
44889   {
44890     try {
44891       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44892     } catch (std::out_of_range& e) {
44893       {
44894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44895       };
44896     } catch (std::exception& e) {
44897       {
44898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44899       };
44900     } catch (Dali::DaliException e) {
44901       {
44902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44903       };
44904     } catch (...) {
44905       {
44906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44907       };
44908     }
44909   }
44910
44911   jresult = (void *)result;
44912   return jresult;
44913 }
44914
44915
44916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44917   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44918
44919   arg1 = (Dali::CameraActor::Property *)jarg1;
44920   {
44921     try {
44922       delete arg1;
44923     } catch (std::out_of_range& e) {
44924       {
44925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44926       };
44927     } catch (std::exception& e) {
44928       {
44929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44930       };
44931     } catch (Dali::DaliException e) {
44932       {
44933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44934       };
44935     } catch (...) {
44936       {
44937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44938       };
44939     }
44940   }
44941
44942 }
44943
44944
44945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44946   void * jresult ;
44947   Dali::CameraActor *result = 0 ;
44948
44949   {
44950     try {
44951       result = (Dali::CameraActor *)new Dali::CameraActor();
44952     } catch (std::out_of_range& e) {
44953       {
44954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44955       };
44956     } catch (std::exception& e) {
44957       {
44958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44959       };
44960     } catch (Dali::DaliException e) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44963       };
44964     } catch (...) {
44965       {
44966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44967       };
44968     }
44969   }
44970
44971   jresult = (void *)result;
44972   return jresult;
44973 }
44974
44975
44976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44977   void * jresult ;
44978   Dali::CameraActor result;
44979
44980   {
44981     try {
44982       result = Dali::CameraActor::New();
44983     } catch (std::out_of_range& e) {
44984       {
44985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44986       };
44987     } catch (std::exception& e) {
44988       {
44989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44990       };
44991     } catch (Dali::DaliException e) {
44992       {
44993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44994       };
44995     } catch (...) {
44996       {
44997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44998       };
44999     }
45000   }
45001
45002   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45003   return jresult;
45004 }
45005
45006
45007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45008   void * jresult ;
45009   Dali::Size *arg1 = 0 ;
45010   Dali::CameraActor result;
45011
45012   arg1 = (Dali::Size *)jarg1;
45013   if (!arg1) {
45014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45015     return 0;
45016   }
45017   {
45018     try {
45019       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45020     } catch (std::out_of_range& e) {
45021       {
45022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45023       };
45024     } catch (std::exception& e) {
45025       {
45026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45027       };
45028     } catch (Dali::DaliException e) {
45029       {
45030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45031       };
45032     } catch (...) {
45033       {
45034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45035       };
45036     }
45037   }
45038
45039   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45040   return jresult;
45041 }
45042
45043
45044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45045   void * jresult ;
45046   Dali::BaseHandle arg1 ;
45047   Dali::BaseHandle *argp1 ;
45048   Dali::CameraActor result;
45049
45050   argp1 = (Dali::BaseHandle *)jarg1;
45051   if (!argp1) {
45052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45053     return 0;
45054   }
45055   arg1 = *argp1;
45056   {
45057     try {
45058       result = Dali::CameraActor::DownCast(arg1);
45059     } catch (std::out_of_range& e) {
45060       {
45061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45062       };
45063     } catch (std::exception& e) {
45064       {
45065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45066       };
45067     } catch (Dali::DaliException e) {
45068       {
45069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45070       };
45071     } catch (...) {
45072       {
45073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45074       };
45075     }
45076   }
45077
45078   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45085
45086   arg1 = (Dali::CameraActor *)jarg1;
45087   {
45088     try {
45089       delete arg1;
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45097       };
45098     } catch (Dali::DaliException e) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45101       };
45102     } catch (...) {
45103       {
45104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45105       };
45106     }
45107   }
45108
45109 }
45110
45111
45112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45113   void * jresult ;
45114   Dali::CameraActor *arg1 = 0 ;
45115   Dali::CameraActor *result = 0 ;
45116
45117   arg1 = (Dali::CameraActor *)jarg1;
45118   if (!arg1) {
45119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45120     return 0;
45121   }
45122   {
45123     try {
45124       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45125     } catch (std::out_of_range& e) {
45126       {
45127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45128       };
45129     } catch (std::exception& e) {
45130       {
45131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45132       };
45133     } catch (Dali::DaliException e) {
45134       {
45135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45136       };
45137     } catch (...) {
45138       {
45139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45140       };
45141     }
45142   }
45143
45144   jresult = (void *)result;
45145   return jresult;
45146 }
45147
45148
45149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45150   void * jresult ;
45151   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45152   Dali::CameraActor *arg2 = 0 ;
45153   Dali::CameraActor *result = 0 ;
45154
45155   arg1 = (Dali::CameraActor *)jarg1;
45156   arg2 = (Dali::CameraActor *)jarg2;
45157   if (!arg2) {
45158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45159     return 0;
45160   }
45161   {
45162     try {
45163       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
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_SetType(void * jarg1, int jarg2) {
45189   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45190   Dali::Camera::Type arg2 ;
45191
45192   arg1 = (Dali::CameraActor *)jarg1;
45193   arg2 = (Dali::Camera::Type)jarg2;
45194   {
45195     try {
45196       (arg1)->SetType(arg2);
45197     } catch (std::out_of_range& e) {
45198       {
45199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45200       };
45201     } catch (std::exception& e) {
45202       {
45203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45204       };
45205     } catch (Dali::DaliException e) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45212       };
45213     }
45214   }
45215
45216 }
45217
45218
45219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45220   int jresult ;
45221   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45222   Dali::Camera::Type result;
45223
45224   arg1 = (Dali::CameraActor *)jarg1;
45225   {
45226     try {
45227       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45228     } catch (std::out_of_range& e) {
45229       {
45230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (std::exception& e) {
45233       {
45234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (Dali::DaliException e) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45243       };
45244     }
45245   }
45246
45247   jresult = (int)result;
45248   return jresult;
45249 }
45250
45251
45252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45253   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45254   Dali::Camera::ProjectionMode arg2 ;
45255
45256   arg1 = (Dali::CameraActor *)jarg1;
45257   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45258   {
45259     try {
45260       (arg1)->SetProjectionMode(arg2);
45261     } catch (std::out_of_range& e) {
45262       {
45263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45264       };
45265     } catch (std::exception& e) {
45266       {
45267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45268       };
45269     } catch (Dali::DaliException e) {
45270       {
45271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45272       };
45273     } catch (...) {
45274       {
45275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45276       };
45277     }
45278   }
45279
45280 }
45281
45282
45283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45284   int jresult ;
45285   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45286   Dali::Camera::ProjectionMode result;
45287
45288   arg1 = (Dali::CameraActor *)jarg1;
45289   {
45290     try {
45291       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45292     } catch (std::out_of_range& e) {
45293       {
45294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45295       };
45296     } catch (std::exception& e) {
45297       {
45298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45299       };
45300     } catch (Dali::DaliException e) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45303       };
45304     } catch (...) {
45305       {
45306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45307       };
45308     }
45309   }
45310
45311   jresult = (int)result;
45312   return jresult;
45313 }
45314
45315
45316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45317   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45318   float arg2 ;
45319
45320   arg1 = (Dali::CameraActor *)jarg1;
45321   arg2 = (float)jarg2;
45322   {
45323     try {
45324       (arg1)->SetFieldOfView(arg2);
45325     } catch (std::out_of_range& e) {
45326       {
45327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45328       };
45329     } catch (std::exception& e) {
45330       {
45331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45332       };
45333     } catch (Dali::DaliException e) {
45334       {
45335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45336       };
45337     } catch (...) {
45338       {
45339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45340       };
45341     }
45342   }
45343
45344 }
45345
45346
45347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45348   float jresult ;
45349   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45350   float result;
45351
45352   arg1 = (Dali::CameraActor *)jarg1;
45353   {
45354     try {
45355       result = (float)(arg1)->GetFieldOfView();
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45363       };
45364     } catch (Dali::DaliException e) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45367       };
45368     } catch (...) {
45369       {
45370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45371       };
45372     }
45373   }
45374
45375   jresult = result;
45376   return jresult;
45377 }
45378
45379
45380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45381   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45382   float arg2 ;
45383
45384   arg1 = (Dali::CameraActor *)jarg1;
45385   arg2 = (float)jarg2;
45386   {
45387     try {
45388       (arg1)->SetAspectRatio(arg2);
45389     } catch (std::out_of_range& e) {
45390       {
45391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45392       };
45393     } catch (std::exception& e) {
45394       {
45395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45396       };
45397     } catch (Dali::DaliException e) {
45398       {
45399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45400       };
45401     } catch (...) {
45402       {
45403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45404       };
45405     }
45406   }
45407
45408 }
45409
45410
45411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45412   float jresult ;
45413   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45414   float result;
45415
45416   arg1 = (Dali::CameraActor *)jarg1;
45417   {
45418     try {
45419       result = (float)(arg1)->GetAspectRatio();
45420     } catch (std::out_of_range& e) {
45421       {
45422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45423       };
45424     } catch (std::exception& e) {
45425       {
45426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45427       };
45428     } catch (Dali::DaliException e) {
45429       {
45430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45431       };
45432     } catch (...) {
45433       {
45434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45435       };
45436     }
45437   }
45438
45439   jresult = result;
45440   return jresult;
45441 }
45442
45443
45444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45445   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45446   float arg2 ;
45447
45448   arg1 = (Dali::CameraActor *)jarg1;
45449   arg2 = (float)jarg2;
45450   {
45451     try {
45452       (arg1)->SetNearClippingPlane(arg2);
45453     } catch (std::out_of_range& e) {
45454       {
45455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45456       };
45457     } catch (std::exception& e) {
45458       {
45459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45460       };
45461     } catch (Dali::DaliException e) {
45462       {
45463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45464       };
45465     } catch (...) {
45466       {
45467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45468       };
45469     }
45470   }
45471
45472 }
45473
45474
45475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45476   float jresult ;
45477   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45478   float result;
45479
45480   arg1 = (Dali::CameraActor *)jarg1;
45481   {
45482     try {
45483       result = (float)(arg1)->GetNearClippingPlane();
45484     } catch (std::out_of_range& e) {
45485       {
45486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45487       };
45488     } catch (std::exception& e) {
45489       {
45490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45491       };
45492     } catch (Dali::DaliException e) {
45493       {
45494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45495       };
45496     } catch (...) {
45497       {
45498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45499       };
45500     }
45501   }
45502
45503   jresult = result;
45504   return jresult;
45505 }
45506
45507
45508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45509   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45510   float arg2 ;
45511
45512   arg1 = (Dali::CameraActor *)jarg1;
45513   arg2 = (float)jarg2;
45514   {
45515     try {
45516       (arg1)->SetFarClippingPlane(arg2);
45517     } catch (std::out_of_range& e) {
45518       {
45519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45520       };
45521     } catch (std::exception& e) {
45522       {
45523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45524       };
45525     } catch (Dali::DaliException e) {
45526       {
45527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45528       };
45529     } catch (...) {
45530       {
45531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45532       };
45533     }
45534   }
45535
45536 }
45537
45538
45539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45540   float jresult ;
45541   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45542   float result;
45543
45544   arg1 = (Dali::CameraActor *)jarg1;
45545   {
45546     try {
45547       result = (float)(arg1)->GetFarClippingPlane();
45548     } catch (std::out_of_range& e) {
45549       {
45550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45551       };
45552     } catch (std::exception& e) {
45553       {
45554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45555       };
45556     } catch (Dali::DaliException e) {
45557       {
45558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45559       };
45560     } catch (...) {
45561       {
45562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45563       };
45564     }
45565   }
45566
45567   jresult = result;
45568   return jresult;
45569 }
45570
45571
45572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45573   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45574   Dali::Vector3 *arg2 = 0 ;
45575
45576   arg1 = (Dali::CameraActor *)jarg1;
45577   arg2 = (Dali::Vector3 *)jarg2;
45578   if (!arg2) {
45579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45580     return ;
45581   }
45582   {
45583     try {
45584       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45585     } catch (std::out_of_range& e) {
45586       {
45587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45588       };
45589     } catch (std::exception& e) {
45590       {
45591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45592       };
45593     } catch (Dali::DaliException e) {
45594       {
45595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45596       };
45597     } catch (...) {
45598       {
45599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45600       };
45601     }
45602   }
45603
45604 }
45605
45606
45607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45608   void * jresult ;
45609   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45610   Dali::Vector3 result;
45611
45612   arg1 = (Dali::CameraActor *)jarg1;
45613   {
45614     try {
45615       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45616     } catch (std::out_of_range& e) {
45617       {
45618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45619       };
45620     } catch (std::exception& e) {
45621       {
45622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45623       };
45624     } catch (Dali::DaliException e) {
45625       {
45626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45627       };
45628     } catch (...) {
45629       {
45630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45631       };
45632     }
45633   }
45634
45635   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45636   return jresult;
45637 }
45638
45639
45640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45641   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45642   bool arg2 ;
45643
45644   arg1 = (Dali::CameraActor *)jarg1;
45645   arg2 = jarg2 ? true : false;
45646   {
45647     try {
45648       (arg1)->SetInvertYAxis(arg2);
45649     } catch (std::out_of_range& e) {
45650       {
45651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45652       };
45653     } catch (std::exception& e) {
45654       {
45655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45656       };
45657     } catch (Dali::DaliException e) {
45658       {
45659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45660       };
45661     } catch (...) {
45662       {
45663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45664       };
45665     }
45666   }
45667
45668 }
45669
45670
45671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45672   unsigned int jresult ;
45673   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45674   bool result;
45675
45676   arg1 = (Dali::CameraActor *)jarg1;
45677   {
45678     try {
45679       result = (bool)(arg1)->GetInvertYAxis();
45680     } catch (std::out_of_range& e) {
45681       {
45682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45683       };
45684     } catch (std::exception& e) {
45685       {
45686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45687       };
45688     } catch (Dali::DaliException e) {
45689       {
45690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45691       };
45692     } catch (...) {
45693       {
45694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45695       };
45696     }
45697   }
45698
45699   jresult = result;
45700   return jresult;
45701 }
45702
45703
45704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45705   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45706   Dali::Size *arg2 = 0 ;
45707
45708   arg1 = (Dali::CameraActor *)jarg1;
45709   arg2 = (Dali::Size *)jarg2;
45710   if (!arg2) {
45711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45712     return ;
45713   }
45714   {
45715     try {
45716       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45717     } catch (std::out_of_range& e) {
45718       {
45719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45720       };
45721     } catch (std::exception& e) {
45722       {
45723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45724       };
45725     } catch (Dali::DaliException e) {
45726       {
45727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45728       };
45729     } catch (...) {
45730       {
45731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45732       };
45733     }
45734   }
45735
45736 }
45737
45738
45739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45740   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45741   Dali::Size *arg2 = 0 ;
45742
45743   arg1 = (Dali::CameraActor *)jarg1;
45744   arg2 = (Dali::Size *)jarg2;
45745   if (!arg2) {
45746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45747     return ;
45748   }
45749   {
45750     try {
45751       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45752     } catch (std::out_of_range& e) {
45753       {
45754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45755       };
45756     } catch (std::exception& e) {
45757       {
45758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45759       };
45760     } catch (Dali::DaliException e) {
45761       {
45762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45763       };
45764     } catch (...) {
45765       {
45766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45767       };
45768     }
45769   }
45770
45771 }
45772
45773
45774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45775   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45776   float arg2 ;
45777   float arg3 ;
45778   float arg4 ;
45779   float arg5 ;
45780   float arg6 ;
45781   float arg7 ;
45782
45783   arg1 = (Dali::CameraActor *)jarg1;
45784   arg2 = (float)jarg2;
45785   arg3 = (float)jarg3;
45786   arg4 = (float)jarg4;
45787   arg5 = (float)jarg5;
45788   arg6 = (float)jarg6;
45789   arg7 = (float)jarg7;
45790   {
45791     try {
45792       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45793     } catch (std::out_of_range& e) {
45794       {
45795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45796       };
45797     } catch (std::exception& e) {
45798       {
45799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45800       };
45801     } catch (Dali::DaliException e) {
45802       {
45803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45804       };
45805     } catch (...) {
45806       {
45807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45808       };
45809     }
45810   }
45811
45812 }
45813
45814
45815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45816   void * jresult ;
45817   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45818
45819   {
45820     try {
45821       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45822     } catch (std::out_of_range& e) {
45823       {
45824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45825       };
45826     } catch (std::exception& e) {
45827       {
45828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (Dali::DaliException e) {
45831       {
45832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45833       };
45834     } catch (...) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45837       };
45838     }
45839   }
45840
45841   jresult = (void *)result;
45842   return jresult;
45843 }
45844
45845
45846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45847   void * jresult ;
45848   std::string arg1 ;
45849   Dali::Property::Value arg2 ;
45850   Dali::Property::Value *argp2 ;
45851   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45852
45853   if (!jarg1) {
45854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45855     return 0;
45856   }
45857   (&arg1)->assign(jarg1);
45858   argp2 = (Dali::Property::Value *)jarg2;
45859   if (!argp2) {
45860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45861     return 0;
45862   }
45863   arg2 = *argp2;
45864   {
45865     try {
45866       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45867     } catch (std::out_of_range& e) {
45868       {
45869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45870       };
45871     } catch (std::exception& e) {
45872       {
45873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45874       };
45875     } catch (Dali::DaliException e) {
45876       {
45877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45878       };
45879     } catch (...) {
45880       {
45881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45882       };
45883     }
45884   }
45885
45886   jresult = (void *)result;
45887   return jresult;
45888 }
45889
45890
45891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45892   void * jresult ;
45893   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45894   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45895
45896   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45897   if (!arg1) {
45898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45899     return 0;
45900   }
45901   {
45902     try {
45903       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);
45904     } catch (std::out_of_range& e) {
45905       {
45906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45907       };
45908     } catch (std::exception& e) {
45909       {
45910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45911       };
45912     } catch (Dali::DaliException e) {
45913       {
45914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45915       };
45916     } catch (...) {
45917       {
45918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45919       };
45920     }
45921   }
45922
45923   jresult = (void *)result;
45924   return jresult;
45925 }
45926
45927
45928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45929   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45930   std::string *arg2 = 0 ;
45931
45932   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45933   if (!jarg2) {
45934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45935     return ;
45936   }
45937   std::string arg2_str(jarg2);
45938   arg2 = &arg2_str;
45939   if (arg1) (arg1)->first = *arg2;
45940
45941   //argout typemap for const std::string&
45942
45943 }
45944
45945
45946 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45947   char * jresult ;
45948   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45949   std::string *result = 0 ;
45950
45951   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45952   result = (std::string *) & ((arg1)->first);
45953   jresult = SWIG_csharp_string_callback(result->c_str());
45954   return jresult;
45955 }
45956
45957
45958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45959   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45960   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45961
45962   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45963   arg2 = (Dali::Property::Value *)jarg2;
45964   if (arg1) (arg1)->second = *arg2;
45965 }
45966
45967
45968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45969   void * jresult ;
45970   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45971   Dali::Property::Value *result = 0 ;
45972
45973   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45974   result = (Dali::Property::Value *)& ((arg1)->second);
45975   jresult = (void *)result;
45976   return jresult;
45977 }
45978
45979
45980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45981   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45982
45983   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45984   {
45985     try {
45986       delete arg1;
45987     } catch (std::out_of_range& e) {
45988       {
45989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45990       };
45991     } catch (std::exception& e) {
45992       {
45993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45994       };
45995     } catch (Dali::DaliException e) {
45996       {
45997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45998       };
45999     } catch (...) {
46000       {
46001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46002       };
46003     }
46004   }
46005
46006 }
46007
46008
46009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46010   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46011
46012   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46013   {
46014     try {
46015       (arg1)->clear();
46016     } catch (std::out_of_range& e) {
46017       {
46018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46019       };
46020     } catch (std::exception& e) {
46021       {
46022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46023       };
46024     } catch (Dali::DaliException e) {
46025       {
46026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46027       };
46028     } catch (...) {
46029       {
46030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46031       };
46032     }
46033   }
46034
46035 }
46036
46037
46038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46039   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46040   Dali::TouchPoint *arg2 = 0 ;
46041
46042   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46043   arg2 = (Dali::TouchPoint *)jarg2;
46044   if (!arg2) {
46045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46046     return ;
46047   }
46048   {
46049     try {
46050       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46051     } catch (std::out_of_range& e) {
46052       {
46053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46054       };
46055     } catch (std::exception& e) {
46056       {
46057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46058       };
46059     } catch (Dali::DaliException e) {
46060       {
46061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46062       };
46063     } catch (...) {
46064       {
46065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46066       };
46067     }
46068   }
46069
46070 }
46071
46072
46073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46074   unsigned long jresult ;
46075   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46076   std::vector< Dali::TouchPoint >::size_type result;
46077
46078   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46079   {
46080     try {
46081       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46082     } catch (std::out_of_range& e) {
46083       {
46084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46085       };
46086     } catch (std::exception& e) {
46087       {
46088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46089       };
46090     } catch (Dali::DaliException e) {
46091       {
46092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46093       };
46094     } catch (...) {
46095       {
46096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46097       };
46098     }
46099   }
46100
46101   jresult = (unsigned long)result;
46102   return jresult;
46103 }
46104
46105
46106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46107   unsigned long jresult ;
46108   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46109   std::vector< Dali::TouchPoint >::size_type result;
46110
46111   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46112   {
46113     try {
46114       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46115     } catch (std::out_of_range& e) {
46116       {
46117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46118       };
46119     } catch (std::exception& e) {
46120       {
46121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46122       };
46123     } catch (Dali::DaliException e) {
46124       {
46125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46126       };
46127     } catch (...) {
46128       {
46129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46130       };
46131     }
46132   }
46133
46134   jresult = (unsigned long)result;
46135   return jresult;
46136 }
46137
46138
46139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46140   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46141   std::vector< Dali::TouchPoint >::size_type arg2 ;
46142
46143   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46144   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46145   {
46146     try {
46147       (arg1)->reserve(arg2);
46148     } catch (std::out_of_range& e) {
46149       {
46150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46151       };
46152     } catch (std::exception& e) {
46153       {
46154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46155       };
46156     } catch (Dali::DaliException e) {
46157       {
46158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46159       };
46160     } catch (...) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46163       };
46164     }
46165   }
46166
46167 }
46168
46169
46170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46171   void * jresult ;
46172   std::vector< Dali::TouchPoint > *result = 0 ;
46173
46174   {
46175     try {
46176       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46177     } catch (std::out_of_range& e) {
46178       {
46179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46180       };
46181     } catch (std::exception& e) {
46182       {
46183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46184       };
46185     } catch (Dali::DaliException e) {
46186       {
46187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46188       };
46189     } catch (...) {
46190       {
46191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46192       };
46193     }
46194   }
46195
46196   jresult = (void *)result;
46197   return jresult;
46198 }
46199
46200
46201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46202   void * jresult ;
46203   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46204   std::vector< Dali::TouchPoint > *result = 0 ;
46205
46206   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46207   if (!arg1) {
46208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46209     return 0;
46210   }
46211   {
46212     try {
46213       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46214     } catch (std::out_of_range& e) {
46215       {
46216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46217       };
46218     } catch (std::exception& e) {
46219       {
46220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46221       };
46222     } catch (Dali::DaliException e) {
46223       {
46224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46225       };
46226     } catch (...) {
46227       {
46228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46229       };
46230     }
46231   }
46232
46233   jresult = (void *)result;
46234   return jresult;
46235 }
46236
46237
46238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46239   void * jresult ;
46240   int arg1 ;
46241   std::vector< Dali::TouchPoint > *result = 0 ;
46242
46243   arg1 = (int)jarg1;
46244   {
46245     try {
46246       try {
46247         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46248       }
46249       catch(std::out_of_range &_e) {
46250         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46251         return 0;
46252       }
46253
46254     } catch (std::out_of_range& e) {
46255       {
46256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46257       };
46258     } catch (std::exception& e) {
46259       {
46260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46261       };
46262     } catch (Dali::DaliException e) {
46263       {
46264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46265       };
46266     } catch (...) {
46267       {
46268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46269       };
46270     }
46271   }
46272
46273   jresult = (void *)result;
46274   return jresult;
46275 }
46276
46277
46278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46279   void * jresult ;
46280   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46281   int arg2 ;
46282   SwigValueWrapper< Dali::TouchPoint > result;
46283
46284   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46285   arg2 = (int)jarg2;
46286   {
46287     try {
46288       try {
46289         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46290       }
46291       catch(std::out_of_range &_e) {
46292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46293         return 0;
46294       }
46295
46296     } catch (std::out_of_range& e) {
46297       {
46298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46299       };
46300     } catch (std::exception& e) {
46301       {
46302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46303       };
46304     } catch (Dali::DaliException e) {
46305       {
46306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46307       };
46308     } catch (...) {
46309       {
46310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46311       };
46312     }
46313   }
46314
46315   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46316   return jresult;
46317 }
46318
46319
46320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46321   void * jresult ;
46322   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46323   int arg2 ;
46324   Dali::TouchPoint *result = 0 ;
46325
46326   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46327   arg2 = (int)jarg2;
46328   {
46329     try {
46330       try {
46331         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46332       }
46333       catch(std::out_of_range &_e) {
46334         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46335         return 0;
46336       }
46337
46338     } catch (std::out_of_range& e) {
46339       {
46340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46341       };
46342     } catch (std::exception& e) {
46343       {
46344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46345       };
46346     } catch (Dali::DaliException e) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46349       };
46350     } catch (...) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46353       };
46354     }
46355   }
46356
46357   jresult = (void *)result;
46358   return jresult;
46359 }
46360
46361
46362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46363   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46364   int arg2 ;
46365   Dali::TouchPoint *arg3 = 0 ;
46366
46367   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46368   arg2 = (int)jarg2;
46369   arg3 = (Dali::TouchPoint *)jarg3;
46370   if (!arg3) {
46371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46372     return ;
46373   }
46374   {
46375     try {
46376       try {
46377         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46378       }
46379       catch(std::out_of_range &_e) {
46380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46381         return ;
46382       }
46383
46384     } catch (std::out_of_range& e) {
46385       {
46386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46387       };
46388     } catch (std::exception& e) {
46389       {
46390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46391       };
46392     } catch (Dali::DaliException e) {
46393       {
46394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46395       };
46396     } catch (...) {
46397       {
46398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46399       };
46400     }
46401   }
46402
46403 }
46404
46405
46406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46407   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46408   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46409
46410   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46411   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46412   if (!arg2) {
46413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46414     return ;
46415   }
46416   {
46417     try {
46418       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46419     } catch (std::out_of_range& e) {
46420       {
46421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46422       };
46423     } catch (std::exception& e) {
46424       {
46425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46426       };
46427     } catch (Dali::DaliException e) {
46428       {
46429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46430       };
46431     } catch (...) {
46432       {
46433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46434       };
46435     }
46436   }
46437
46438 }
46439
46440
46441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46442   void * jresult ;
46443   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46444   int arg2 ;
46445   int arg3 ;
46446   std::vector< Dali::TouchPoint > *result = 0 ;
46447
46448   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46449   arg2 = (int)jarg2;
46450   arg3 = (int)jarg3;
46451   {
46452     try {
46453       try {
46454         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46455       }
46456       catch(std::out_of_range &_e) {
46457         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46458         return 0;
46459       }
46460       catch(std::invalid_argument &_e) {
46461         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46462         return 0;
46463       }
46464
46465     } catch (std::out_of_range& e) {
46466       {
46467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46468       };
46469     } catch (std::exception& e) {
46470       {
46471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (Dali::DaliException e) {
46474       {
46475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46476       };
46477     } catch (...) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46480       };
46481     }
46482   }
46483
46484   jresult = (void *)result;
46485   return jresult;
46486 }
46487
46488
46489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46490   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46491   int arg2 ;
46492   Dali::TouchPoint *arg3 = 0 ;
46493
46494   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46495   arg2 = (int)jarg2;
46496   arg3 = (Dali::TouchPoint *)jarg3;
46497   if (!arg3) {
46498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46499     return ;
46500   }
46501   {
46502     try {
46503       try {
46504         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46505       }
46506       catch(std::out_of_range &_e) {
46507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46508         return ;
46509       }
46510
46511     } catch (std::out_of_range& e) {
46512       {
46513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46514       };
46515     } catch (std::exception& e) {
46516       {
46517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46518       };
46519     } catch (Dali::DaliException e) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46526       };
46527     }
46528   }
46529
46530 }
46531
46532
46533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46534   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46535   int arg2 ;
46536   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46537
46538   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46539   arg2 = (int)jarg2;
46540   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46541   if (!arg3) {
46542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46543     return ;
46544   }
46545   {
46546     try {
46547       try {
46548         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46549       }
46550       catch(std::out_of_range &_e) {
46551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46552         return ;
46553       }
46554
46555     } catch (std::out_of_range& e) {
46556       {
46557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46558       };
46559     } catch (std::exception& e) {
46560       {
46561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46562       };
46563     } catch (Dali::DaliException e) {
46564       {
46565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46566       };
46567     } catch (...) {
46568       {
46569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46570       };
46571     }
46572   }
46573
46574 }
46575
46576
46577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46578   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46579   int arg2 ;
46580
46581   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46582   arg2 = (int)jarg2;
46583   {
46584     try {
46585       try {
46586         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46587       }
46588       catch(std::out_of_range &_e) {
46589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46590         return ;
46591       }
46592
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46600       };
46601     } catch (Dali::DaliException e) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46604       };
46605     } catch (...) {
46606       {
46607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46608       };
46609     }
46610   }
46611
46612 }
46613
46614
46615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46616   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46617   int arg2 ;
46618   int arg3 ;
46619
46620   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46621   arg2 = (int)jarg2;
46622   arg3 = (int)jarg3;
46623   {
46624     try {
46625       try {
46626         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46627       }
46628       catch(std::out_of_range &_e) {
46629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46630         return ;
46631       }
46632       catch(std::invalid_argument &_e) {
46633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46634         return ;
46635       }
46636
46637     } catch (std::out_of_range& e) {
46638       {
46639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46640       };
46641     } catch (std::exception& e) {
46642       {
46643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46644       };
46645     } catch (Dali::DaliException e) {
46646       {
46647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46648       };
46649     } catch (...) {
46650       {
46651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46652       };
46653     }
46654   }
46655
46656 }
46657
46658
46659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46660   void * jresult ;
46661   Dali::TouchPoint *arg1 = 0 ;
46662   int arg2 ;
46663   std::vector< Dali::TouchPoint > *result = 0 ;
46664
46665   arg1 = (Dali::TouchPoint *)jarg1;
46666   if (!arg1) {
46667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46668     return 0;
46669   }
46670   arg2 = (int)jarg2;
46671   {
46672     try {
46673       try {
46674         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46675       }
46676       catch(std::out_of_range &_e) {
46677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46678         return 0;
46679       }
46680
46681     } catch (std::out_of_range& e) {
46682       {
46683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46684       };
46685     } catch (std::exception& e) {
46686       {
46687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46688       };
46689     } catch (Dali::DaliException e) {
46690       {
46691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46692       };
46693     } catch (...) {
46694       {
46695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46696       };
46697     }
46698   }
46699
46700   jresult = (void *)result;
46701   return jresult;
46702 }
46703
46704
46705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46706   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46707
46708   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46709   {
46710     try {
46711       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46712     } catch (std::out_of_range& e) {
46713       {
46714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46715       };
46716     } catch (std::exception& e) {
46717       {
46718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46719       };
46720     } catch (Dali::DaliException e) {
46721       {
46722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46723       };
46724     } catch (...) {
46725       {
46726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46727       };
46728     }
46729   }
46730
46731 }
46732
46733
46734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46735   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46736   int arg2 ;
46737   int arg3 ;
46738
46739   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46740   arg2 = (int)jarg2;
46741   arg3 = (int)jarg3;
46742   {
46743     try {
46744       try {
46745         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46746       }
46747       catch(std::out_of_range &_e) {
46748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46749         return ;
46750       }
46751       catch(std::invalid_argument &_e) {
46752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46753         return ;
46754       }
46755
46756     } catch (std::out_of_range& e) {
46757       {
46758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46759       };
46760     } catch (std::exception& e) {
46761       {
46762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46763       };
46764     } catch (Dali::DaliException e) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46767       };
46768     } catch (...) {
46769       {
46770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46771       };
46772     }
46773   }
46774
46775 }
46776
46777
46778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46779   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46780   int arg2 ;
46781   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46782
46783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46784   arg2 = (int)jarg2;
46785   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46786   if (!arg3) {
46787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46788     return ;
46789   }
46790   {
46791     try {
46792       try {
46793         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46794       }
46795       catch(std::out_of_range &_e) {
46796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46797         return ;
46798       }
46799
46800     } catch (std::out_of_range& e) {
46801       {
46802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46803       };
46804     } catch (std::exception& e) {
46805       {
46806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46807       };
46808     } catch (Dali::DaliException e) {
46809       {
46810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46811       };
46812     } catch (...) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46815       };
46816     }
46817   }
46818
46819 }
46820
46821
46822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46824
46825   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46826   {
46827     try {
46828       delete arg1;
46829     } catch (std::out_of_range& e) {
46830       {
46831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46832       };
46833     } catch (std::exception& e) {
46834       {
46835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46836       };
46837     } catch (Dali::DaliException e) {
46838       {
46839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46840       };
46841     } catch (...) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46844       };
46845     }
46846   }
46847
46848 }
46849
46850
46851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46852   void * jresult ;
46853   Dali::Rect< int > *result = 0 ;
46854
46855   {
46856     try {
46857       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46858     } catch (std::out_of_range& e) {
46859       {
46860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46861       };
46862     } catch (std::exception& e) {
46863       {
46864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46865       };
46866     } catch (Dali::DaliException e) {
46867       {
46868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46873       };
46874     }
46875   }
46876
46877   jresult = (void *)result;
46878   return jresult;
46879 }
46880
46881
46882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46883   void * jresult ;
46884   int arg1 ;
46885   int arg2 ;
46886   int arg3 ;
46887   int arg4 ;
46888   Dali::Rect< int > *result = 0 ;
46889
46890   arg1 = (int)jarg1;
46891   arg2 = (int)jarg2;
46892   arg3 = (int)jarg3;
46893   arg4 = (int)jarg4;
46894   {
46895     try {
46896       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46897     } catch (std::out_of_range& e) {
46898       {
46899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (std::exception& e) {
46902       {
46903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (Dali::DaliException e) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46908       };
46909     } catch (...) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46912       };
46913     }
46914   }
46915
46916   jresult = (void *)result;
46917   return jresult;
46918 }
46919
46920
46921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46922   void * jresult ;
46923   Dali::Rect< int > *arg1 = 0 ;
46924   Dali::Rect< int > *result = 0 ;
46925
46926   arg1 = (Dali::Rect< int > *)jarg1;
46927   if (!arg1) {
46928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46929     return 0;
46930   }
46931   {
46932     try {
46933       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46934     } catch (std::out_of_range& e) {
46935       {
46936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46937       };
46938     } catch (std::exception& e) {
46939       {
46940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (Dali::DaliException e) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46945       };
46946     } catch (...) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46949       };
46950     }
46951   }
46952
46953   jresult = (void *)result;
46954   return jresult;
46955 }
46956
46957
46958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46959   void * jresult ;
46960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46961   Dali::Rect< int > *arg2 = 0 ;
46962   Dali::Rect< int > *result = 0 ;
46963
46964   arg1 = (Dali::Rect< int > *)jarg1;
46965   arg2 = (Dali::Rect< int > *)jarg2;
46966   if (!arg2) {
46967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46968     return 0;
46969   }
46970   {
46971     try {
46972       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46973     } catch (std::out_of_range& e) {
46974       {
46975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (std::exception& e) {
46978       {
46979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (Dali::DaliException e) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46984       };
46985     } catch (...) {
46986       {
46987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46988       };
46989     }
46990   }
46991
46992   jresult = (void *)result;
46993   return jresult;
46994 }
46995
46996
46997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46998   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46999   int arg2 ;
47000   int arg3 ;
47001   int arg4 ;
47002   int arg5 ;
47003
47004   arg1 = (Dali::Rect< int > *)jarg1;
47005   arg2 = (int)jarg2;
47006   arg3 = (int)jarg3;
47007   arg4 = (int)jarg4;
47008   arg5 = (int)jarg5;
47009   {
47010     try {
47011       (arg1)->Set(arg2,arg3,arg4,arg5);
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 unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47035   unsigned int jresult ;
47036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47037   bool result;
47038
47039   arg1 = (Dali::Rect< int > *)jarg1;
47040   {
47041     try {
47042       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47043     } catch (std::out_of_range& e) {
47044       {
47045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47046       };
47047     } catch (std::exception& e) {
47048       {
47049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47050       };
47051     } catch (Dali::DaliException e) {
47052       {
47053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47054       };
47055     } catch (...) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47058       };
47059     }
47060   }
47061
47062   jresult = result;
47063   return jresult;
47064 }
47065
47066
47067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47068   int jresult ;
47069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47070   int result;
47071
47072   arg1 = (Dali::Rect< int > *)jarg1;
47073   {
47074     try {
47075       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47076     } catch (std::out_of_range& e) {
47077       {
47078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (std::exception& e) {
47081       {
47082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47083       };
47084     } catch (Dali::DaliException e) {
47085       {
47086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47087       };
47088     } catch (...) {
47089       {
47090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47091       };
47092     }
47093   }
47094
47095   jresult = result;
47096   return jresult;
47097 }
47098
47099
47100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47101   int jresult ;
47102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47103   int result;
47104
47105   arg1 = (Dali::Rect< int > *)jarg1;
47106   {
47107     try {
47108       result = (int)((Dali::Rect< int > const *)arg1)->Right();
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 = result;
47129   return jresult;
47130 }
47131
47132
47133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47134   int jresult ;
47135   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47136   int result;
47137
47138   arg1 = (Dali::Rect< int > *)jarg1;
47139   {
47140     try {
47141       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47142     } catch (std::out_of_range& e) {
47143       {
47144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47145       };
47146     } catch (std::exception& e) {
47147       {
47148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47149       };
47150     } catch (Dali::DaliException e) {
47151       {
47152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47153       };
47154     } catch (...) {
47155       {
47156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47157       };
47158     }
47159   }
47160
47161   jresult = result;
47162   return jresult;
47163 }
47164
47165
47166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47167   int jresult ;
47168   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47169   int result;
47170
47171   arg1 = (Dali::Rect< int > *)jarg1;
47172   {
47173     try {
47174       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (Dali::DaliException e) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47186       };
47187     } catch (...) {
47188       {
47189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47190       };
47191     }
47192   }
47193
47194   jresult = result;
47195   return jresult;
47196 }
47197
47198
47199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47200   int jresult ;
47201   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47202   int result;
47203
47204   arg1 = (Dali::Rect< int > *)jarg1;
47205   {
47206     try {
47207       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47208     } catch (std::out_of_range& e) {
47209       {
47210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47211       };
47212     } catch (std::exception& e) {
47213       {
47214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (Dali::DaliException e) {
47217       {
47218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47219       };
47220     } catch (...) {
47221       {
47222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47223       };
47224     }
47225   }
47226
47227   jresult = result;
47228   return jresult;
47229 }
47230
47231
47232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47233   unsigned int jresult ;
47234   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47235   Dali::Rect< int > *arg2 = 0 ;
47236   bool result;
47237
47238   arg1 = (Dali::Rect< int > *)jarg1;
47239   arg2 = (Dali::Rect< int > *)jarg2;
47240   if (!arg2) {
47241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47242     return 0;
47243   }
47244   {
47245     try {
47246       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47247     } catch (std::out_of_range& e) {
47248       {
47249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47250       };
47251     } catch (std::exception& e) {
47252       {
47253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47254       };
47255     } catch (Dali::DaliException e) {
47256       {
47257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47258       };
47259     } catch (...) {
47260       {
47261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47262       };
47263     }
47264   }
47265
47266   jresult = result;
47267   return jresult;
47268 }
47269
47270
47271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47272   unsigned int jresult ;
47273   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47274   Dali::Rect< int > *arg2 = 0 ;
47275   bool result;
47276
47277   arg1 = (Dali::Rect< int > *)jarg1;
47278   arg2 = (Dali::Rect< int > *)jarg2;
47279   if (!arg2) {
47280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47281     return 0;
47282   }
47283   {
47284     try {
47285       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47286     } catch (std::out_of_range& e) {
47287       {
47288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47289       };
47290     } catch (std::exception& e) {
47291       {
47292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47293       };
47294     } catch (Dali::DaliException e) {
47295       {
47296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47297       };
47298     } catch (...) {
47299       {
47300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47301       };
47302     }
47303   }
47304
47305   jresult = result;
47306   return jresult;
47307 }
47308
47309
47310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47311   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47312   int arg2 ;
47313
47314   arg1 = (Dali::Rect< int > *)jarg1;
47315   arg2 = (int)jarg2;
47316   if (arg1) (arg1)->x = arg2;
47317 }
47318
47319
47320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47321   int jresult ;
47322   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47323   int result;
47324
47325   arg1 = (Dali::Rect< int > *)jarg1;
47326   result = (int) ((arg1)->x);
47327   jresult = result;
47328   return jresult;
47329 }
47330
47331
47332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47333   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47334   int arg2 ;
47335
47336   arg1 = (Dali::Rect< int > *)jarg1;
47337   arg2 = (int)jarg2;
47338   if (arg1) (arg1)->left = arg2;
47339 }
47340
47341
47342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47343   int jresult ;
47344   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47345   int result;
47346
47347   arg1 = (Dali::Rect< int > *)jarg1;
47348   result = (int) ((arg1)->left);
47349   jresult = result;
47350   return jresult;
47351 }
47352
47353
47354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47355   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47356   int arg2 ;
47357
47358   arg1 = (Dali::Rect< int > *)jarg1;
47359   arg2 = (int)jarg2;
47360   if (arg1) (arg1)->y = arg2;
47361 }
47362
47363
47364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47365   int jresult ;
47366   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47367   int result;
47368
47369   arg1 = (Dali::Rect< int > *)jarg1;
47370   result = (int) ((arg1)->y);
47371   jresult = result;
47372   return jresult;
47373 }
47374
47375
47376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47377   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47378   int arg2 ;
47379
47380   arg1 = (Dali::Rect< int > *)jarg1;
47381   arg2 = (int)jarg2;
47382   if (arg1) (arg1)->right = arg2;
47383 }
47384
47385
47386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47387   int jresult ;
47388   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47389   int result;
47390
47391   arg1 = (Dali::Rect< int > *)jarg1;
47392   result = (int) ((arg1)->right);
47393   jresult = result;
47394   return jresult;
47395 }
47396
47397
47398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47399   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47400   int arg2 ;
47401
47402   arg1 = (Dali::Rect< int > *)jarg1;
47403   arg2 = (int)jarg2;
47404   if (arg1) (arg1)->width = arg2;
47405 }
47406
47407
47408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47409   int jresult ;
47410   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47411   int result;
47412
47413   arg1 = (Dali::Rect< int > *)jarg1;
47414   result = (int) ((arg1)->width);
47415   jresult = result;
47416   return jresult;
47417 }
47418
47419
47420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47421   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47422   int arg2 ;
47423
47424   arg1 = (Dali::Rect< int > *)jarg1;
47425   arg2 = (int)jarg2;
47426   if (arg1) (arg1)->bottom = arg2;
47427 }
47428
47429
47430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47431   int jresult ;
47432   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47433   int result;
47434
47435   arg1 = (Dali::Rect< int > *)jarg1;
47436   result = (int) ((arg1)->bottom);
47437   jresult = result;
47438   return jresult;
47439 }
47440
47441
47442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47443   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47444   int arg2 ;
47445
47446   arg1 = (Dali::Rect< int > *)jarg1;
47447   arg2 = (int)jarg2;
47448   if (arg1) (arg1)->height = arg2;
47449 }
47450
47451
47452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47453   int jresult ;
47454   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47455   int result;
47456
47457   arg1 = (Dali::Rect< int > *)jarg1;
47458   result = (int) ((arg1)->height);
47459   jresult = result;
47460   return jresult;
47461 }
47462
47463
47464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47465   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47466   int arg2 ;
47467
47468   arg1 = (Dali::Rect< int > *)jarg1;
47469   arg2 = (int)jarg2;
47470   if (arg1) (arg1)->top = arg2;
47471 }
47472
47473
47474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47475   int jresult ;
47476   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47477   int result;
47478
47479   arg1 = (Dali::Rect< int > *)jarg1;
47480   result = (int) ((arg1)->top);
47481   jresult = result;
47482   return jresult;
47483 }
47484
47485
47486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47487   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47488
47489   arg1 = (Dali::Rect< int > *)jarg1;
47490   {
47491     try {
47492       delete arg1;
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47500       };
47501     } catch (Dali::DaliException e) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47504       };
47505     } catch (...) {
47506       {
47507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47508       };
47509     }
47510   }
47511
47512 }
47513
47514
47515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47516   void * jresult ;
47517   Dali::Rect< float > *result = 0 ;
47518
47519   {
47520     try {
47521       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47522     } catch (std::out_of_range& e) {
47523       {
47524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47525       };
47526     } catch (std::exception& e) {
47527       {
47528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47529       };
47530     } catch (Dali::DaliException e) {
47531       {
47532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47533       };
47534     } catch (...) {
47535       {
47536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47537       };
47538     }
47539   }
47540
47541   jresult = (void *)result;
47542   return jresult;
47543 }
47544
47545
47546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47547   void * jresult ;
47548   float arg1 ;
47549   float arg2 ;
47550   float arg3 ;
47551   float arg4 ;
47552   Dali::Rect< float > *result = 0 ;
47553
47554   arg1 = (float)jarg1;
47555   arg2 = (float)jarg2;
47556   arg3 = (float)jarg4;
47557   arg4 = (float)jarg3;
47558   {
47559     try {
47560       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47561     } catch (std::out_of_range& e) {
47562       {
47563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47564       };
47565     } catch (std::exception& e) {
47566       {
47567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (Dali::DaliException e) {
47570       {
47571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47572       };
47573     } catch (...) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47576       };
47577     }
47578   }
47579
47580   jresult = (void *)result;
47581   return jresult;
47582 }
47583
47584
47585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47586   void * jresult ;
47587   Dali::Rect< float > *arg1 = 0 ;
47588   Dali::Rect< float > *result = 0 ;
47589
47590   arg1 = (Dali::Rect< float > *)jarg1;
47591   if (!arg1) {
47592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47593     return 0;
47594   }
47595   {
47596     try {
47597       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47598     } catch (std::out_of_range& e) {
47599       {
47600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47601       };
47602     } catch (std::exception& e) {
47603       {
47604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47605       };
47606     } catch (Dali::DaliException e) {
47607       {
47608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47609       };
47610     } catch (...) {
47611       {
47612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47613       };
47614     }
47615   }
47616
47617   jresult = (void *)result;
47618   return jresult;
47619 }
47620
47621
47622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47623   void * jresult ;
47624   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47625   Dali::Rect< float > *arg2 = 0 ;
47626   Dali::Rect< float > *result = 0 ;
47627
47628   arg1 = (Dali::Rect< float > *)jarg1;
47629   arg2 = (Dali::Rect< float > *)jarg2;
47630   if (!arg2) {
47631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47632     return 0;
47633   }
47634   {
47635     try {
47636       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47637     } catch (std::out_of_range& e) {
47638       {
47639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47640       };
47641     } catch (std::exception& e) {
47642       {
47643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47644       };
47645     } catch (Dali::DaliException e) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47652       };
47653     }
47654   }
47655
47656   jresult = (void *)result;
47657   return jresult;
47658 }
47659
47660
47661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47663   float arg2 ;
47664   float arg3 ;
47665   float arg4 ;
47666   float arg5 ;
47667
47668   arg1 = (Dali::Rect< float > *)jarg1;
47669   arg2 = (float)jarg2;
47670   arg3 = (float)jarg3;
47671   arg4 = (float)jarg5;
47672   arg5 = (float)jarg4;
47673   {
47674     try {
47675       (arg1)->Set(arg2,arg3,arg4,arg5);
47676     } catch (std::out_of_range& e) {
47677       {
47678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47679       };
47680     } catch (std::exception& e) {
47681       {
47682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47683       };
47684     } catch (Dali::DaliException e) {
47685       {
47686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47687       };
47688     } catch (...) {
47689       {
47690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47691       };
47692     }
47693   }
47694
47695 }
47696
47697
47698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47699   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47700   float arg2 ;
47701
47702   arg1 = (Dali::Rect< float > *)jarg1;
47703   arg2 = (float)jarg2;
47704   if (arg1) (arg1)->left = arg2;
47705 }
47706
47707
47708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47709   float jresult ;
47710   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47711   float result;
47712
47713   arg1 = (Dali::Rect< float > *)jarg1;
47714   result = (float) ((arg1)->left);
47715   jresult = result;
47716   return jresult;
47717 }
47718
47719
47720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47721   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47722   float arg2 ;
47723
47724   arg1 = (Dali::Rect< float > *)jarg1;
47725   arg2 = (float)jarg2;
47726   if (arg1) (arg1)->left = arg2;
47727 }
47728
47729
47730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47731   float jresult ;
47732   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47733   float result;
47734
47735   arg1 = (Dali::Rect< float > *)jarg1;
47736   result = (float) ((arg1)->left);
47737   jresult = result;
47738   return jresult;
47739 }
47740
47741
47742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47743   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47744   float arg2 ;
47745
47746   arg1 = (Dali::Rect< float > *)jarg1;
47747   arg2 = (float)jarg2;
47748   if (arg1) (arg1)->right = arg2;
47749 }
47750
47751
47752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47753   float jresult ;
47754   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47755   float result;
47756
47757   arg1 = (Dali::Rect< float > *)jarg1;
47758   result = (float) ((arg1)->right);
47759   jresult = result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47765   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47766   float arg2 ;
47767
47768   arg1 = (Dali::Rect< float > *)jarg1;
47769   arg2 = (float)jarg2;
47770   if (arg1) (arg1)->right = arg2;
47771 }
47772
47773
47774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47775   float jresult ;
47776   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47777   float result;
47778
47779   arg1 = (Dali::Rect< float > *)jarg1;
47780   result = (float) ((arg1)->right);
47781   jresult = result;
47782   return jresult;
47783 }
47784
47785
47786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47787   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47788   float arg2 ;
47789
47790   arg1 = (Dali::Rect< float > *)jarg1;
47791   arg2 = (float)jarg2;
47792   if (arg1) (arg1)->bottom = arg2;
47793 }
47794
47795
47796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47797   float jresult ;
47798   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47799   float result;
47800
47801   arg1 = (Dali::Rect< float > *)jarg1;
47802   result = (float) ((arg1)->bottom);
47803   jresult = result;
47804   return jresult;
47805 }
47806
47807
47808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47809   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47810   float arg2 ;
47811
47812   arg1 = (Dali::Rect< float > *)jarg1;
47813   arg2 = (float)jarg2;
47814   if (arg1) (arg1)->top = arg2;
47815 }
47816
47817
47818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47819   float jresult ;
47820   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47821   float result;
47822
47823   arg1 = (Dali::Rect< float > *)jarg1;
47824   result = (float) ((arg1)->top);
47825   jresult = result;
47826   return jresult;
47827 }
47828
47829
47830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47831   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47832
47833   arg1 = (Dali::Rect< float > *)jarg1;
47834   {
47835     try {
47836       delete arg1;
47837     } catch (std::out_of_range& e) {
47838       {
47839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47840       };
47841     } catch (std::exception& e) {
47842       {
47843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47844       };
47845     } catch (Dali::DaliException e) {
47846       {
47847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47848       };
47849     } catch (...) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47852       };
47853     }
47854   }
47855
47856 }
47857
47858
47859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47860   int jresult ;
47861   int result;
47862
47863   result = (int)Dali::Vector< int >::BaseType;
47864   jresult = (int)result;
47865   return jresult;
47866 }
47867
47868
47869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47870   void * jresult ;
47871   Dali::Vector< int > *result = 0 ;
47872
47873   {
47874     try {
47875       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (Dali::DaliException e) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47891       };
47892     }
47893   }
47894
47895   jresult = (void *)result;
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47901   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47902
47903   arg1 = (Dali::Vector< int > *)jarg1;
47904   {
47905     try {
47906       delete arg1;
47907     } catch (std::out_of_range& e) {
47908       {
47909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47910       };
47911     } catch (std::exception& e) {
47912       {
47913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47914       };
47915     } catch (Dali::DaliException e) {
47916       {
47917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47918       };
47919     } catch (...) {
47920       {
47921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47922       };
47923     }
47924   }
47925
47926 }
47927
47928
47929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47930   void * jresult ;
47931   Dali::Vector< int > *arg1 = 0 ;
47932   Dali::Vector< int > *result = 0 ;
47933
47934   arg1 = (Dali::Vector< int > *)jarg1;
47935   if (!arg1) {
47936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47937     return 0;
47938   }
47939   {
47940     try {
47941       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47942     } catch (std::out_of_range& e) {
47943       {
47944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47945       };
47946     } catch (std::exception& e) {
47947       {
47948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47949       };
47950     } catch (Dali::DaliException e) {
47951       {
47952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47953       };
47954     } catch (...) {
47955       {
47956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47957       };
47958     }
47959   }
47960
47961   jresult = (void *)result;
47962   return jresult;
47963 }
47964
47965
47966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47967   void * jresult ;
47968   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47969   Dali::Vector< int > *arg2 = 0 ;
47970   Dali::Vector< int > *result = 0 ;
47971
47972   arg1 = (Dali::Vector< int > *)jarg1;
47973   arg2 = (Dali::Vector< int > *)jarg2;
47974   if (!arg2) {
47975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47976     return 0;
47977   }
47978   {
47979     try {
47980       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47981     } catch (std::out_of_range& e) {
47982       {
47983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47984       };
47985     } catch (std::exception& e) {
47986       {
47987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47988       };
47989     } catch (Dali::DaliException e) {
47990       {
47991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47992       };
47993     } catch (...) {
47994       {
47995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47996       };
47997     }
47998   }
47999
48000   jresult = (void *)result;
48001   return jresult;
48002 }
48003
48004
48005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48006   void * jresult ;
48007   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48008   Dali::Vector< int >::Iterator result;
48009
48010   arg1 = (Dali::Vector< int > *)jarg1;
48011   {
48012     try {
48013       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48014     } catch (std::out_of_range& e) {
48015       {
48016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48017       };
48018     } catch (std::exception& e) {
48019       {
48020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48021       };
48022     } catch (Dali::DaliException e) {
48023       {
48024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48025       };
48026     } catch (...) {
48027       {
48028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48029       };
48030     }
48031   }
48032
48033   jresult = (void *)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48039   void * jresult ;
48040   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48041   Dali::Vector< int >::Iterator result;
48042
48043   arg1 = (Dali::Vector< int > *)jarg1;
48044   {
48045     try {
48046       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48047     } catch (std::out_of_range& e) {
48048       {
48049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48050       };
48051     } catch (std::exception& e) {
48052       {
48053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (Dali::DaliException e) {
48056       {
48057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48058       };
48059     } catch (...) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48062       };
48063     }
48064   }
48065
48066   jresult = (void *)result;
48067   return jresult;
48068 }
48069
48070
48071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48072   void * jresult ;
48073   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48074   Dali::Vector< int >::SizeType arg2 ;
48075   Dali::Vector< int >::ItemType *result = 0 ;
48076
48077   arg1 = (Dali::Vector< int > *)jarg1;
48078   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48079   {
48080     try {
48081       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48082     } catch (std::out_of_range& e) {
48083       {
48084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48085       };
48086     } catch (std::exception& e) {
48087       {
48088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48089       };
48090     } catch (Dali::DaliException e) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48097       };
48098     }
48099   }
48100
48101   jresult = (void *)result;
48102   return jresult;
48103 }
48104
48105
48106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48107   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48108   Dali::Vector< int >::ItemType *arg2 = 0 ;
48109   Dali::Vector< int >::ItemType temp2 ;
48110
48111   arg1 = (Dali::Vector< int > *)jarg1;
48112   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48113   arg2 = &temp2;
48114   {
48115     try {
48116       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48117     } catch (std::out_of_range& e) {
48118       {
48119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48120       };
48121     } catch (std::exception& e) {
48122       {
48123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48124       };
48125     } catch (Dali::DaliException e) {
48126       {
48127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48128       };
48129     } catch (...) {
48130       {
48131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48132       };
48133     }
48134   }
48135
48136 }
48137
48138
48139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48140   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48141   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48142   Dali::Vector< int >::ItemType *arg3 = 0 ;
48143   Dali::Vector< int >::ItemType temp3 ;
48144
48145   arg1 = (Dali::Vector< int > *)jarg1;
48146   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48147   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48148   arg3 = &temp3;
48149   {
48150     try {
48151       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48152     } catch (std::out_of_range& e) {
48153       {
48154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48155       };
48156     } catch (std::exception& e) {
48157       {
48158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48159       };
48160     } catch (Dali::DaliException e) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48163       };
48164     } catch (...) {
48165       {
48166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48167       };
48168     }
48169   }
48170
48171 }
48172
48173
48174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48175   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48176   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48177   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48178   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48179
48180   arg1 = (Dali::Vector< int > *)jarg1;
48181   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48182   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48183   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48184   {
48185     try {
48186       (arg1)->Insert(arg2,arg3,arg4);
48187     } catch (std::out_of_range& e) {
48188       {
48189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48190       };
48191     } catch (std::exception& e) {
48192       {
48193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48194       };
48195     } catch (Dali::DaliException e) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48198       };
48199     } catch (...) {
48200       {
48201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48202       };
48203     }
48204   }
48205
48206 }
48207
48208
48209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48210   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48211   Dali::Vector< int >::SizeType arg2 ;
48212
48213   arg1 = (Dali::Vector< int > *)jarg1;
48214   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48215   {
48216     try {
48217       (arg1)->Reserve(arg2);
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48225       };
48226     } catch (Dali::DaliException e) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48229       };
48230     } catch (...) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48233       };
48234     }
48235   }
48236
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48241   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48242   Dali::Vector< int >::SizeType arg2 ;
48243
48244   arg1 = (Dali::Vector< int > *)jarg1;
48245   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48246   {
48247     try {
48248       (arg1)->Resize(arg2);
48249     } catch (std::out_of_range& e) {
48250       {
48251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (std::exception& e) {
48254       {
48255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48256       };
48257     } catch (Dali::DaliException e) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48260       };
48261     } catch (...) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48264       };
48265     }
48266   }
48267
48268 }
48269
48270
48271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48272   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48273   Dali::Vector< int >::SizeType arg2 ;
48274   Dali::Vector< int >::ItemType *arg3 = 0 ;
48275   Dali::Vector< int >::ItemType temp3 ;
48276
48277   arg1 = (Dali::Vector< int > *)jarg1;
48278   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48279   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48280   arg3 = &temp3;
48281   {
48282     try {
48283       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48284     } catch (std::out_of_range& e) {
48285       {
48286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48287       };
48288     } catch (std::exception& e) {
48289       {
48290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48291       };
48292     } catch (Dali::DaliException e) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48295       };
48296     } catch (...) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48299       };
48300     }
48301   }
48302
48303 }
48304
48305
48306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48307   void * jresult ;
48308   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48309   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48310   Dali::Vector< int >::Iterator result;
48311
48312   arg1 = (Dali::Vector< int > *)jarg1;
48313   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48314   {
48315     try {
48316       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48317     } catch (std::out_of_range& e) {
48318       {
48319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48320       };
48321     } catch (std::exception& e) {
48322       {
48323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48324       };
48325     } catch (Dali::DaliException e) {
48326       {
48327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48328       };
48329     } catch (...) {
48330       {
48331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48332       };
48333     }
48334   }
48335
48336   jresult = (void *)result;
48337   return jresult;
48338 }
48339
48340
48341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48342   void * jresult ;
48343   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48344   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48345   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48346   Dali::Vector< int >::Iterator result;
48347
48348   arg1 = (Dali::Vector< int > *)jarg1;
48349   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48350   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48351   {
48352     try {
48353       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48354     } catch (std::out_of_range& e) {
48355       {
48356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48357       };
48358     } catch (std::exception& e) {
48359       {
48360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48361       };
48362     } catch (Dali::DaliException e) {
48363       {
48364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48365       };
48366     } catch (...) {
48367       {
48368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48369       };
48370     }
48371   }
48372
48373   jresult = (void *)result;
48374   return jresult;
48375 }
48376
48377
48378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48379   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48380   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48381
48382   arg1 = (Dali::Vector< int > *)jarg1;
48383   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48384   {
48385     try {
48386       (arg1)->Remove(arg2);
48387     } catch (std::out_of_range& e) {
48388       {
48389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48390       };
48391     } catch (std::exception& e) {
48392       {
48393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48394       };
48395     } catch (Dali::DaliException e) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48398       };
48399     } catch (...) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48402       };
48403     }
48404   }
48405
48406 }
48407
48408
48409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48410   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48411   Dali::Vector< int > *arg2 = 0 ;
48412
48413   arg1 = (Dali::Vector< int > *)jarg1;
48414   arg2 = (Dali::Vector< int > *)jarg2;
48415   if (!arg2) {
48416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48417     return ;
48418   }
48419   {
48420     try {
48421       (arg1)->Swap(*arg2);
48422     } catch (std::out_of_range& e) {
48423       {
48424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48425       };
48426     } catch (std::exception& e) {
48427       {
48428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48429       };
48430     } catch (Dali::DaliException e) {
48431       {
48432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48433       };
48434     } catch (...) {
48435       {
48436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48437       };
48438     }
48439   }
48440
48441 }
48442
48443
48444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48445   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48446
48447   arg1 = (Dali::Vector< int > *)jarg1;
48448   {
48449     try {
48450       (arg1)->Clear();
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48458       };
48459     } catch (Dali::DaliException e) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48462       };
48463     } catch (...) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48466       };
48467     }
48468   }
48469
48470 }
48471
48472
48473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48474   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48475
48476   arg1 = (Dali::Vector< int > *)jarg1;
48477   {
48478     try {
48479       (arg1)->Release();
48480     } catch (std::out_of_range& e) {
48481       {
48482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48483       };
48484     } catch (std::exception& e) {
48485       {
48486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (Dali::DaliException e) {
48489       {
48490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48491       };
48492     } catch (...) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48495       };
48496     }
48497   }
48498
48499 }
48500
48501
48502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48503   int jresult ;
48504   int result;
48505
48506   result = (int)Dali::Vector< float >::BaseType;
48507   jresult = (int)result;
48508   return jresult;
48509 }
48510
48511
48512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48513   void * jresult ;
48514   Dali::Vector< float > *result = 0 ;
48515
48516   {
48517     try {
48518       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48519     } catch (std::out_of_range& e) {
48520       {
48521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (std::exception& e) {
48524       {
48525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48526       };
48527     } catch (Dali::DaliException e) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48530       };
48531     } catch (...) {
48532       {
48533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48534       };
48535     }
48536   }
48537
48538   jresult = (void *)result;
48539   return jresult;
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48544   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48545
48546   arg1 = (Dali::Vector< float > *)jarg1;
48547   {
48548     try {
48549       delete arg1;
48550     } catch (std::out_of_range& e) {
48551       {
48552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48553       };
48554     } catch (std::exception& e) {
48555       {
48556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48557       };
48558     } catch (Dali::DaliException e) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48561       };
48562     } catch (...) {
48563       {
48564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48565       };
48566     }
48567   }
48568
48569 }
48570
48571
48572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48573   void * jresult ;
48574   Dali::Vector< float > *arg1 = 0 ;
48575   Dali::Vector< float > *result = 0 ;
48576
48577   arg1 = (Dali::Vector< float > *)jarg1;
48578   if (!arg1) {
48579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48580     return 0;
48581   }
48582   {
48583     try {
48584       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48585     } catch (std::out_of_range& e) {
48586       {
48587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48588       };
48589     } catch (std::exception& e) {
48590       {
48591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48592       };
48593     } catch (Dali::DaliException e) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48596       };
48597     } catch (...) {
48598       {
48599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48600       };
48601     }
48602   }
48603
48604   jresult = (void *)result;
48605   return jresult;
48606 }
48607
48608
48609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48610   void * jresult ;
48611   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48612   Dali::Vector< float > *arg2 = 0 ;
48613   Dali::Vector< float > *result = 0 ;
48614
48615   arg1 = (Dali::Vector< float > *)jarg1;
48616   arg2 = (Dali::Vector< float > *)jarg2;
48617   if (!arg2) {
48618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48619     return 0;
48620   }
48621   {
48622     try {
48623       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48624     } catch (std::out_of_range& e) {
48625       {
48626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48627       };
48628     } catch (std::exception& e) {
48629       {
48630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48631       };
48632     } catch (Dali::DaliException e) {
48633       {
48634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48635       };
48636     } catch (...) {
48637       {
48638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48639       };
48640     }
48641   }
48642
48643   jresult = (void *)result;
48644   return jresult;
48645 }
48646
48647
48648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48649   void * jresult ;
48650   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48651   Dali::Vector< float >::Iterator result;
48652
48653   arg1 = (Dali::Vector< float > *)jarg1;
48654   {
48655     try {
48656       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48657     } catch (std::out_of_range& e) {
48658       {
48659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48660       };
48661     } catch (std::exception& e) {
48662       {
48663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48664       };
48665     } catch (Dali::DaliException e) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48668       };
48669     } catch (...) {
48670       {
48671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48672       };
48673     }
48674   }
48675
48676   jresult = (void *)result;
48677   return jresult;
48678 }
48679
48680
48681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48682   void * jresult ;
48683   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48684   Dali::Vector< float >::Iterator result;
48685
48686   arg1 = (Dali::Vector< float > *)jarg1;
48687   {
48688     try {
48689       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48690     } catch (std::out_of_range& e) {
48691       {
48692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48693       };
48694     } catch (std::exception& e) {
48695       {
48696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48697       };
48698     } catch (Dali::DaliException e) {
48699       {
48700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48701       };
48702     } catch (...) {
48703       {
48704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48705       };
48706     }
48707   }
48708
48709   jresult = (void *)result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48715   void * jresult ;
48716   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48717   Dali::Vector< float >::SizeType arg2 ;
48718   Dali::Vector< float >::ItemType *result = 0 ;
48719
48720   arg1 = (Dali::Vector< float > *)jarg1;
48721   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48722   {
48723     try {
48724       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48725     } catch (std::out_of_range& e) {
48726       {
48727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48728       };
48729     } catch (std::exception& e) {
48730       {
48731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48732       };
48733     } catch (Dali::DaliException e) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48736       };
48737     } catch (...) {
48738       {
48739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48740       };
48741     }
48742   }
48743
48744   jresult = (void *)result;
48745   return jresult;
48746 }
48747
48748
48749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48750   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48751   Dali::Vector< float >::ItemType *arg2 = 0 ;
48752   Dali::Vector< float >::ItemType temp2 ;
48753
48754   arg1 = (Dali::Vector< float > *)jarg1;
48755   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48756   arg2 = &temp2;
48757   {
48758     try {
48759       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48760     } catch (std::out_of_range& e) {
48761       {
48762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48763       };
48764     } catch (std::exception& e) {
48765       {
48766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48767       };
48768     } catch (Dali::DaliException e) {
48769       {
48770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48771       };
48772     } catch (...) {
48773       {
48774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48775       };
48776     }
48777   }
48778
48779 }
48780
48781
48782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48783   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48784   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48785   Dali::Vector< float >::ItemType *arg3 = 0 ;
48786   Dali::Vector< float >::ItemType temp3 ;
48787
48788   arg1 = (Dali::Vector< float > *)jarg1;
48789   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48790   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48791   arg3 = &temp3;
48792   {
48793     try {
48794       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48795     } catch (std::out_of_range& e) {
48796       {
48797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48798       };
48799     } catch (std::exception& e) {
48800       {
48801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48802       };
48803     } catch (Dali::DaliException e) {
48804       {
48805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48806       };
48807     } catch (...) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48810       };
48811     }
48812   }
48813
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48818   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48819   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48820   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48821   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48822
48823   arg1 = (Dali::Vector< float > *)jarg1;
48824   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48825   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48826   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48827   {
48828     try {
48829       (arg1)->Insert(arg2,arg3,arg4);
48830     } catch (std::out_of_range& e) {
48831       {
48832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48833       };
48834     } catch (std::exception& e) {
48835       {
48836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (Dali::DaliException e) {
48839       {
48840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848
48849 }
48850
48851
48852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48853   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48854   Dali::Vector< float >::SizeType arg2 ;
48855
48856   arg1 = (Dali::Vector< float > *)jarg1;
48857   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48858   {
48859     try {
48860       (arg1)->Reserve(arg2);
48861     } catch (std::out_of_range& e) {
48862       {
48863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48864       };
48865     } catch (std::exception& e) {
48866       {
48867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48868       };
48869     } catch (Dali::DaliException e) {
48870       {
48871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48872       };
48873     } catch (...) {
48874       {
48875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48876       };
48877     }
48878   }
48879
48880 }
48881
48882 //// ========================= end of part 2 =============================
48883
48884 //// ========================== start part 3 ===============================
48885
48886
48887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48888   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48889   Dali::Vector< float >::SizeType arg2 ;
48890
48891   arg1 = (Dali::Vector< float > *)jarg1;
48892   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48893   {
48894     try {
48895       (arg1)->Resize(arg2);
48896     } catch (std::out_of_range& e) {
48897       {
48898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48899       };
48900     } catch (std::exception& e) {
48901       {
48902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (Dali::DaliException e) {
48905       {
48906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48907       };
48908     } catch (...) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48911       };
48912     }
48913   }
48914
48915 }
48916
48917
48918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48919   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48920   Dali::Vector< float >::SizeType arg2 ;
48921   Dali::Vector< float >::ItemType *arg3 = 0 ;
48922   Dali::Vector< float >::ItemType temp3 ;
48923
48924   arg1 = (Dali::Vector< float > *)jarg1;
48925   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48926   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48927   arg3 = &temp3;
48928   {
48929     try {
48930       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48931     } catch (std::out_of_range& e) {
48932       {
48933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48934       };
48935     } catch (std::exception& e) {
48936       {
48937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48938       };
48939     } catch (Dali::DaliException e) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48942       };
48943     } catch (...) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48946       };
48947     }
48948   }
48949
48950 }
48951
48952
48953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48954   void * jresult ;
48955   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48956   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48957   Dali::Vector< float >::Iterator result;
48958
48959   arg1 = (Dali::Vector< float > *)jarg1;
48960   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48961   {
48962     try {
48963       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48964     } catch (std::out_of_range& e) {
48965       {
48966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48967       };
48968     } catch (std::exception& e) {
48969       {
48970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48971       };
48972     } catch (Dali::DaliException e) {
48973       {
48974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48975       };
48976     } catch (...) {
48977       {
48978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48979       };
48980     }
48981   }
48982
48983   jresult = (void *)result;
48984   return jresult;
48985 }
48986
48987
48988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48989   void * jresult ;
48990   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48991   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48992   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48993   Dali::Vector< float >::Iterator result;
48994
48995   arg1 = (Dali::Vector< float > *)jarg1;
48996   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48997   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48998   {
48999     try {
49000       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49001     } catch (std::out_of_range& e) {
49002       {
49003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49004       };
49005     } catch (std::exception& e) {
49006       {
49007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49008       };
49009     } catch (Dali::DaliException e) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49012       };
49013     } catch (...) {
49014       {
49015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49016       };
49017     }
49018   }
49019
49020   jresult = (void *)result;
49021   return jresult;
49022 }
49023
49024
49025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49026   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49027   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49028
49029   arg1 = (Dali::Vector< float > *)jarg1;
49030   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49031   {
49032     try {
49033       (arg1)->Remove(arg2);
49034     } catch (std::out_of_range& e) {
49035       {
49036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49037       };
49038     } catch (std::exception& e) {
49039       {
49040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49041       };
49042     } catch (Dali::DaliException e) {
49043       {
49044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49045       };
49046     } catch (...) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49049       };
49050     }
49051   }
49052
49053 }
49054
49055
49056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49057   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49058   Dali::Vector< float > *arg2 = 0 ;
49059
49060   arg1 = (Dali::Vector< float > *)jarg1;
49061   arg2 = (Dali::Vector< float > *)jarg2;
49062   if (!arg2) {
49063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49064     return ;
49065   }
49066   {
49067     try {
49068       (arg1)->Swap(*arg2);
49069     } catch (std::out_of_range& e) {
49070       {
49071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49072       };
49073     } catch (std::exception& e) {
49074       {
49075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49076       };
49077     } catch (Dali::DaliException e) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49080       };
49081     } catch (...) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49084       };
49085     }
49086   }
49087
49088 }
49089
49090
49091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49092   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49093
49094   arg1 = (Dali::Vector< float > *)jarg1;
49095   {
49096     try {
49097       (arg1)->Clear();
49098     } catch (std::out_of_range& e) {
49099       {
49100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49101       };
49102     } catch (std::exception& e) {
49103       {
49104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49105       };
49106     } catch (Dali::DaliException e) {
49107       {
49108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49109       };
49110     } catch (...) {
49111       {
49112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49113       };
49114     }
49115   }
49116
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49121   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49122
49123   arg1 = (Dali::Vector< float > *)jarg1;
49124   {
49125     try {
49126       (arg1)->Release();
49127     } catch (std::out_of_range& e) {
49128       {
49129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49130       };
49131     } catch (std::exception& e) {
49132       {
49133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49134       };
49135     } catch (Dali::DaliException e) {
49136       {
49137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49138       };
49139     } catch (...) {
49140       {
49141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49142       };
49143     }
49144   }
49145
49146 }
49147
49148
49149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49150   int jresult ;
49151   int result;
49152
49153   result = (int)Dali::Vector< unsigned char >::BaseType;
49154   jresult = (int)result;
49155   return jresult;
49156 }
49157
49158
49159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49160   void * jresult ;
49161   Dali::Vector< unsigned char > *result = 0 ;
49162
49163   {
49164     try {
49165       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49173       };
49174     } catch (Dali::DaliException e) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49177       };
49178     } catch (...) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49181       };
49182     }
49183   }
49184
49185   jresult = (void *)result;
49186   return jresult;
49187 }
49188
49189
49190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49191   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49192
49193   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49194   {
49195     try {
49196       delete arg1;
49197     } catch (std::out_of_range& e) {
49198       {
49199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49200       };
49201     } catch (std::exception& e) {
49202       {
49203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49204       };
49205     } catch (Dali::DaliException e) {
49206       {
49207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49208       };
49209     } catch (...) {
49210       {
49211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49212       };
49213     }
49214   }
49215
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49220   void * jresult ;
49221   Dali::Vector< unsigned char > *arg1 = 0 ;
49222   Dali::Vector< unsigned char > *result = 0 ;
49223
49224   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49225   if (!arg1) {
49226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49227     return 0;
49228   }
49229   {
49230     try {
49231       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (Dali::DaliException e) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49247       };
49248     }
49249   }
49250
49251   jresult = (void *)result;
49252   return jresult;
49253 }
49254
49255
49256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49257   void * jresult ;
49258   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49259   Dali::Vector< unsigned char > *arg2 = 0 ;
49260   Dali::Vector< unsigned char > *result = 0 ;
49261
49262   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49263   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49264   if (!arg2) {
49265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49266     return 0;
49267   }
49268   {
49269     try {
49270       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49271     } catch (std::out_of_range& e) {
49272       {
49273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49274       };
49275     } catch (std::exception& e) {
49276       {
49277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49278       };
49279     } catch (Dali::DaliException e) {
49280       {
49281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49282       };
49283     } catch (...) {
49284       {
49285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49286       };
49287     }
49288   }
49289
49290   jresult = (void *)result;
49291   return jresult;
49292 }
49293
49294
49295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49296   void * jresult ;
49297   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49298   Dali::Vector< unsigned char >::Iterator result;
49299
49300   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49301   {
49302     try {
49303       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49304     } catch (std::out_of_range& e) {
49305       {
49306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49307       };
49308     } catch (std::exception& e) {
49309       {
49310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49311       };
49312     } catch (Dali::DaliException e) {
49313       {
49314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49315       };
49316     } catch (...) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49319       };
49320     }
49321   }
49322
49323   jresult = (void *)result;
49324   return jresult;
49325 }
49326
49327
49328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49329   void * jresult ;
49330   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49331   Dali::Vector< unsigned char >::Iterator result;
49332
49333   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49334   {
49335     try {
49336       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49344       };
49345     } catch (Dali::DaliException e) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49348       };
49349     } catch (...) {
49350       {
49351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49352       };
49353     }
49354   }
49355
49356   jresult = (void *)result;
49357   return jresult;
49358 }
49359
49360
49361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49362   void * jresult ;
49363   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49364   Dali::Vector< unsigned char >::SizeType arg2 ;
49365   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49366
49367   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49368   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49369   {
49370     try {
49371       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49372     } catch (std::out_of_range& e) {
49373       {
49374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (std::exception& e) {
49377       {
49378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (Dali::DaliException e) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49383       };
49384     } catch (...) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49387       };
49388     }
49389   }
49390
49391   jresult = (void *)result;
49392   return jresult;
49393 }
49394
49395
49396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49397   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49398   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49399   Dali::Vector< unsigned char >::ItemType temp2 ;
49400
49401   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49402   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49403   arg2 = &temp2;
49404   {
49405     try {
49406       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49407     } catch (std::out_of_range& e) {
49408       {
49409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49410       };
49411     } catch (std::exception& e) {
49412       {
49413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49414       };
49415     } catch (Dali::DaliException e) {
49416       {
49417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49422       };
49423     }
49424   }
49425
49426 }
49427
49428
49429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49430   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49431   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49432   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49433   Dali::Vector< unsigned char >::ItemType temp3 ;
49434
49435   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49436   arg2 = jarg2;
49437   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49438   arg3 = &temp3;
49439   {
49440     try {
49441       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49442     } catch (std::out_of_range& e) {
49443       {
49444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49445       };
49446     } catch (std::exception& e) {
49447       {
49448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49449       };
49450     } catch (Dali::DaliException e) {
49451       {
49452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49453       };
49454     } catch (...) {
49455       {
49456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49457       };
49458     }
49459   }
49460
49461
49462
49463 }
49464
49465
49466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49467   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49468   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49469   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49470   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49471
49472   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49473   arg2 = jarg2;
49474   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49475   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49476   {
49477     try {
49478       (arg1)->Insert(arg2,arg3,arg4);
49479     } catch (std::out_of_range& e) {
49480       {
49481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49482       };
49483     } catch (std::exception& e) {
49484       {
49485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49486       };
49487     } catch (Dali::DaliException e) {
49488       {
49489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49490       };
49491     } catch (...) {
49492       {
49493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49494       };
49495     }
49496   }
49497
49498
49499
49500 }
49501
49502
49503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49504   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49505   Dali::Vector< unsigned char >::SizeType arg2 ;
49506
49507   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49508   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49509   {
49510     try {
49511       (arg1)->Reserve(arg2);
49512     } catch (std::out_of_range& e) {
49513       {
49514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49515       };
49516     } catch (std::exception& e) {
49517       {
49518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49519       };
49520     } catch (Dali::DaliException e) {
49521       {
49522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49523       };
49524     } catch (...) {
49525       {
49526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49527       };
49528     }
49529   }
49530
49531 }
49532
49533
49534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49536   Dali::Vector< unsigned char >::SizeType arg2 ;
49537
49538   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49539   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49540   {
49541     try {
49542       (arg1)->Resize(arg2);
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49550       };
49551     } catch (Dali::DaliException e) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49554       };
49555     } catch (...) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49558       };
49559     }
49560   }
49561
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49566   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49567   Dali::Vector< unsigned char >::SizeType arg2 ;
49568   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49569   Dali::Vector< unsigned char >::ItemType temp3 ;
49570
49571   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49572   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49573   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49574   arg3 = &temp3;
49575   {
49576     try {
49577       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49578     } catch (std::out_of_range& e) {
49579       {
49580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (std::exception& e) {
49583       {
49584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49585       };
49586     } catch (Dali::DaliException e) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49589       };
49590     } catch (...) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49593       };
49594     }
49595   }
49596
49597 }
49598
49599
49600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49601   void * jresult ;
49602   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49603   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49604   Dali::Vector< unsigned char >::Iterator result;
49605
49606   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49607   arg2 = jarg2;
49608   {
49609     try {
49610       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49618       };
49619     } catch (Dali::DaliException e) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49622       };
49623     } catch (...) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49626       };
49627     }
49628   }
49629
49630   jresult = (void *)result;
49631
49632
49633   return jresult;
49634 }
49635
49636
49637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49638   void * jresult ;
49639   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49640   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49641   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49642   Dali::Vector< unsigned char >::Iterator result;
49643
49644   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49645   arg2 = jarg2;
49646   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49647   {
49648     try {
49649       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49650     } catch (std::out_of_range& e) {
49651       {
49652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49653       };
49654     } catch (std::exception& e) {
49655       {
49656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49657       };
49658     } catch (Dali::DaliException e) {
49659       {
49660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49661       };
49662     } catch (...) {
49663       {
49664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49665       };
49666     }
49667   }
49668
49669   jresult = (void *)result;
49670
49671
49672   return jresult;
49673 }
49674
49675
49676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49677   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49678   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49679
49680   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49681   arg2 = jarg2;
49682   {
49683     try {
49684       (arg1)->Remove(arg2);
49685     } catch (std::out_of_range& e) {
49686       {
49687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49688       };
49689     } catch (std::exception& e) {
49690       {
49691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49692       };
49693     } catch (Dali::DaliException e) {
49694       {
49695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49696       };
49697     } catch (...) {
49698       {
49699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49700       };
49701     }
49702   }
49703
49704
49705
49706 }
49707
49708
49709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49710   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49711   Dali::Vector< unsigned char > *arg2 = 0 ;
49712
49713   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49714   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49715   if (!arg2) {
49716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49717     return ;
49718   }
49719   {
49720     try {
49721       (arg1)->Swap(*arg2);
49722     } catch (std::out_of_range& e) {
49723       {
49724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49725       };
49726     } catch (std::exception& e) {
49727       {
49728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49729       };
49730     } catch (Dali::DaliException e) {
49731       {
49732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49733       };
49734     } catch (...) {
49735       {
49736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49737       };
49738     }
49739   }
49740
49741 }
49742
49743
49744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49745   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49746
49747   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49748   {
49749     try {
49750       (arg1)->Clear();
49751     } catch (std::out_of_range& e) {
49752       {
49753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49754       };
49755     } catch (std::exception& e) {
49756       {
49757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (Dali::DaliException e) {
49760       {
49761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49762       };
49763     } catch (...) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49766       };
49767     }
49768   }
49769
49770 }
49771
49772
49773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49774   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49775
49776   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49777   {
49778     try {
49779       (arg1)->Release();
49780     } catch (std::out_of_range& e) {
49781       {
49782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49783       };
49784     } catch (std::exception& e) {
49785       {
49786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49787       };
49788     } catch (Dali::DaliException e) {
49789       {
49790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49791       };
49792     } catch (...) {
49793       {
49794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49795       };
49796     }
49797   }
49798
49799 }
49800
49801
49802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49803   int jresult ;
49804   int result;
49805
49806   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49807   jresult = (int)result;
49808   return jresult;
49809 }
49810
49811
49812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49813   void * jresult ;
49814   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49815
49816   {
49817     try {
49818       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49819     } catch (std::out_of_range& e) {
49820       {
49821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49822       };
49823     } catch (std::exception& e) {
49824       {
49825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49826       };
49827     } catch (Dali::DaliException e) {
49828       {
49829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49830       };
49831     } catch (...) {
49832       {
49833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49834       };
49835     }
49836   }
49837
49838   jresult = (void *)result;
49839   return jresult;
49840 }
49841
49842
49843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49844   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49845
49846   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49847   {
49848     try {
49849       delete arg1;
49850     } catch (std::out_of_range& e) {
49851       {
49852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49853       };
49854     } catch (std::exception& e) {
49855       {
49856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49857       };
49858     } catch (Dali::DaliException e) {
49859       {
49860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49861       };
49862     } catch (...) {
49863       {
49864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49865       };
49866     }
49867   }
49868
49869 }
49870
49871
49872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49873   void * jresult ;
49874   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49875   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49876
49877   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49878   if (!arg1) {
49879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49880     return 0;
49881   }
49882   {
49883     try {
49884       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49885     } catch (std::out_of_range& e) {
49886       {
49887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49888       };
49889     } catch (std::exception& e) {
49890       {
49891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49892       };
49893     } catch (Dali::DaliException e) {
49894       {
49895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49896       };
49897     } catch (...) {
49898       {
49899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49900       };
49901     }
49902   }
49903
49904   jresult = (void *)result;
49905   return jresult;
49906 }
49907
49908
49909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49910   void * jresult ;
49911   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49912   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49913   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49914
49915   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49916   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49917   if (!arg2) {
49918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49919     return 0;
49920   }
49921   {
49922     try {
49923       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49924     } catch (std::out_of_range& e) {
49925       {
49926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49927       };
49928     } catch (std::exception& e) {
49929       {
49930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49931       };
49932     } catch (Dali::DaliException e) {
49933       {
49934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49935       };
49936     } catch (...) {
49937       {
49938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49939       };
49940     }
49941   }
49942
49943   jresult = (void *)result;
49944   return jresult;
49945 }
49946
49947
49948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49949   void * jresult ;
49950   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49951   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49952
49953   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49954   {
49955     try {
49956       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49972       };
49973     }
49974   }
49975
49976   jresult = (void *)result;
49977   return jresult;
49978 }
49979
49980
49981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49982   void * jresult ;
49983   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49984   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49985
49986   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49987   {
49988     try {
49989       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49990     } catch (std::out_of_range& e) {
49991       {
49992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49993       };
49994     } catch (std::exception& e) {
49995       {
49996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49997       };
49998     } catch (Dali::DaliException e) {
49999       {
50000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50001       };
50002     } catch (...) {
50003       {
50004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50005       };
50006     }
50007   }
50008
50009   jresult = (void *)result;
50010   return jresult;
50011 }
50012
50013
50014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50015   void * jresult ;
50016   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50017   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50018   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50019
50020   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50021   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50022   {
50023     try {
50024       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50025     } catch (std::out_of_range& e) {
50026       {
50027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50028       };
50029     } catch (std::exception& e) {
50030       {
50031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50032       };
50033     } catch (Dali::DaliException e) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50036       };
50037     } catch (...) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50040       };
50041     }
50042   }
50043
50044   jresult = (void *)result;
50045   return jresult;
50046 }
50047
50048
50049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50050   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50051   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50052
50053   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50054   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50055   if (!arg2) {
50056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50057     return ;
50058   }
50059   {
50060     try {
50061       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
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_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50085   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50086   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50087   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50088
50089   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50090   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50091   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50092   if (!arg3) {
50093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50094     return ;
50095   }
50096   {
50097     try {
50098       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50099     } catch (std::out_of_range& e) {
50100       {
50101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50102       };
50103     } catch (std::exception& e) {
50104       {
50105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50106       };
50107     } catch (Dali::DaliException e) {
50108       {
50109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50110       };
50111     } catch (...) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50114       };
50115     }
50116   }
50117
50118 }
50119
50120
50121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50122   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50123   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50124   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50125   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50126
50127   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50128   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50129   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50130   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50131   {
50132     try {
50133       (arg1)->Insert(arg2,arg3,arg4);
50134     } catch (std::out_of_range& e) {
50135       {
50136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50137       };
50138     } catch (std::exception& e) {
50139       {
50140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50141       };
50142     } catch (Dali::DaliException e) {
50143       {
50144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50145       };
50146     } catch (...) {
50147       {
50148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50149       };
50150     }
50151   }
50152
50153 }
50154
50155
50156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50157   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50158   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50159
50160   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50161   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50162   {
50163     try {
50164       (arg1)->Reserve(arg2);
50165     } catch (std::out_of_range& e) {
50166       {
50167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50168       };
50169     } catch (std::exception& e) {
50170       {
50171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50172       };
50173     } catch (Dali::DaliException e) {
50174       {
50175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50176       };
50177     } catch (...) {
50178       {
50179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50180       };
50181     }
50182   }
50183
50184 }
50185
50186
50187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50188   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50189   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50190
50191   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50192   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50193   {
50194     try {
50195       (arg1)->Resize(arg2);
50196     } catch (std::out_of_range& e) {
50197       {
50198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (std::exception& e) {
50201       {
50202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50203       };
50204     } catch (Dali::DaliException e) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50207       };
50208     } catch (...) {
50209       {
50210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50211       };
50212     }
50213   }
50214
50215 }
50216
50217
50218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50219   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50220   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50221   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50222
50223   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50224   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50225   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50226   if (!arg3) {
50227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50228     return ;
50229   }
50230   {
50231     try {
50232       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50233     } catch (std::out_of_range& e) {
50234       {
50235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50236       };
50237     } catch (std::exception& e) {
50238       {
50239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50240       };
50241     } catch (Dali::DaliException e) {
50242       {
50243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50244       };
50245     } catch (...) {
50246       {
50247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50248       };
50249     }
50250   }
50251
50252 }
50253
50254
50255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50256   void * jresult ;
50257   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50258   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50259   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50260
50261   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50262   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50263   {
50264     try {
50265       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50266     } catch (std::out_of_range& e) {
50267       {
50268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50269       };
50270     } catch (std::exception& e) {
50271       {
50272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50273       };
50274     } catch (Dali::DaliException e) {
50275       {
50276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50277       };
50278     } catch (...) {
50279       {
50280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50281       };
50282     }
50283   }
50284
50285   jresult = (void *)result;
50286   return jresult;
50287 }
50288
50289
50290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50291   void * jresult ;
50292   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50293   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50294   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50295   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50296
50297   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50298   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50299   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50300   {
50301     try {
50302       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50303     } catch (std::out_of_range& e) {
50304       {
50305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50306       };
50307     } catch (std::exception& e) {
50308       {
50309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50310       };
50311     } catch (Dali::DaliException e) {
50312       {
50313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50314       };
50315     } catch (...) {
50316       {
50317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50318       };
50319     }
50320   }
50321
50322   jresult = (void *)result;
50323   return jresult;
50324 }
50325
50326
50327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50328   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50329   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50330
50331   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50332   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50333   {
50334     try {
50335       (arg1)->Remove(arg2);
50336     } catch (std::out_of_range& e) {
50337       {
50338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50339       };
50340     } catch (std::exception& e) {
50341       {
50342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50343       };
50344     } catch (Dali::DaliException e) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50347       };
50348     } catch (...) {
50349       {
50350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50351       };
50352     }
50353   }
50354
50355 }
50356
50357
50358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50359   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50360   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50361
50362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50363   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50364   if (!arg2) {
50365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50366     return ;
50367   }
50368   {
50369     try {
50370       (arg1)->Swap(*arg2);
50371     } catch (std::out_of_range& e) {
50372       {
50373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50374       };
50375     } catch (std::exception& e) {
50376       {
50377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50378       };
50379     } catch (Dali::DaliException e) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50382       };
50383     } catch (...) {
50384       {
50385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50386       };
50387     }
50388   }
50389
50390 }
50391
50392
50393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50394   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50395
50396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50397   {
50398     try {
50399       (arg1)->Clear();
50400     } catch (std::out_of_range& e) {
50401       {
50402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50403       };
50404     } catch (std::exception& e) {
50405       {
50406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50407       };
50408     } catch (Dali::DaliException e) {
50409       {
50410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50411       };
50412     } catch (...) {
50413       {
50414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50415       };
50416     }
50417   }
50418
50419 }
50420
50421
50422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50423   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50424
50425   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50426   {
50427     try {
50428       (arg1)->Release();
50429     } catch (std::out_of_range& e) {
50430       {
50431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50432       };
50433     } catch (std::exception& e) {
50434       {
50435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50436       };
50437     } catch (Dali::DaliException e) {
50438       {
50439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50440       };
50441     } catch (...) {
50442       {
50443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50444       };
50445     }
50446   }
50447
50448 }
50449
50450
50451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50452   void * jresult ;
50453   Dali::Signal< void () > *result = 0 ;
50454
50455   {
50456     try {
50457       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50458     } catch (std::out_of_range& e) {
50459       {
50460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50461       };
50462     } catch (std::exception& e) {
50463       {
50464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (Dali::DaliException e) {
50467       {
50468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50469       };
50470     } catch (...) {
50471       {
50472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50473       };
50474     }
50475   }
50476
50477   jresult = (void *)result;
50478   return jresult;
50479 }
50480
50481
50482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50483   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50484
50485   arg1 = (Dali::Signal< void () > *)jarg1;
50486   {
50487     try {
50488       delete arg1;
50489     } catch (std::out_of_range& e) {
50490       {
50491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50492       };
50493     } catch (std::exception& e) {
50494       {
50495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50496       };
50497     } catch (Dali::DaliException e) {
50498       {
50499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50500       };
50501     } catch (...) {
50502       {
50503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50504       };
50505     }
50506   }
50507
50508 }
50509
50510
50511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50512   unsigned int jresult ;
50513   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50514   bool result;
50515
50516   arg1 = (Dali::Signal< void () > *)jarg1;
50517   {
50518     try {
50519       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50520     } catch (std::out_of_range& e) {
50521       {
50522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50523       };
50524     } catch (std::exception& e) {
50525       {
50526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50527       };
50528     } catch (Dali::DaliException e) {
50529       {
50530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50531       };
50532     } catch (...) {
50533       {
50534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50535       };
50536     }
50537   }
50538
50539   jresult = result;
50540   return jresult;
50541 }
50542
50543
50544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50545   unsigned long jresult ;
50546   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50547   std::size_t result;
50548
50549   arg1 = (Dali::Signal< void () > *)jarg1;
50550   {
50551     try {
50552       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50553     } catch (std::out_of_range& e) {
50554       {
50555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50556       };
50557     } catch (std::exception& e) {
50558       {
50559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50560       };
50561     } catch (Dali::DaliException e) {
50562       {
50563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50564       };
50565     } catch (...) {
50566       {
50567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50568       };
50569     }
50570   }
50571
50572   jresult = (unsigned long)result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50578   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50579   void (*arg2)() = (void (*)()) 0 ;
50580
50581   arg1 = (Dali::Signal< void () > *)jarg1;
50582   arg2 = (void (*)())jarg2;
50583   {
50584     try {
50585       (arg1)->Connect(arg2);
50586     } catch (std::out_of_range& e) {
50587       {
50588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50589       };
50590     } catch (std::exception& e) {
50591       {
50592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50593       };
50594     } catch (Dali::DaliException e) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50597       };
50598     } catch (...) {
50599       {
50600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50601       };
50602     }
50603   }
50604
50605 }
50606
50607
50608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50609   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50610   void (*arg2)() = (void (*)()) 0 ;
50611
50612   arg1 = (Dali::Signal< void () > *)jarg1;
50613   arg2 = (void (*)())jarg2;
50614   {
50615     try {
50616       (arg1)->Disconnect(arg2);
50617     } catch (std::out_of_range& e) {
50618       {
50619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50620       };
50621     } catch (std::exception& e) {
50622       {
50623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50624       };
50625     } catch (Dali::DaliException e) {
50626       {
50627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50628       };
50629     } catch (...) {
50630       {
50631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50632       };
50633     }
50634   }
50635
50636 }
50637
50638
50639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50640   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50641   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50642   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50643
50644   arg1 = (Dali::Signal< void () > *)jarg1;
50645   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50646   arg3 = (Dali::FunctorDelegate *)jarg3;
50647   {
50648     try {
50649       (arg1)->Connect(arg2,arg3);
50650     } catch (std::out_of_range& e) {
50651       {
50652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50653       };
50654     } catch (std::exception& e) {
50655       {
50656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50657       };
50658     } catch (Dali::DaliException e) {
50659       {
50660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50661       };
50662     } catch (...) {
50663       {
50664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50665       };
50666     }
50667   }
50668
50669 }
50670
50671
50672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50673   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50674
50675   arg1 = (Dali::Signal< void () > *)jarg1;
50676   {
50677     try {
50678       (arg1)->Emit();
50679     } catch (std::out_of_range& e) {
50680       {
50681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (std::exception& e) {
50684       {
50685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50686       };
50687     } catch (Dali::DaliException e) {
50688       {
50689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50690       };
50691     } catch (...) {
50692       {
50693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50694       };
50695     }
50696   }
50697
50698 }
50699
50700
50701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50702   unsigned int jresult ;
50703   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50704   bool result;
50705
50706   arg1 = (Dali::Signal< void (float) > *)jarg1;
50707   {
50708     try {
50709       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50710     } catch (std::out_of_range& e) {
50711       {
50712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50713       };
50714     } catch (std::exception& e) {
50715       {
50716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50717       };
50718     } catch (Dali::DaliException e) {
50719       {
50720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50721       };
50722     } catch (...) {
50723       {
50724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50725       };
50726     }
50727   }
50728
50729   jresult = result;
50730   return jresult;
50731 }
50732
50733
50734 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50735   unsigned long jresult ;
50736   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50737   std::size_t result;
50738
50739   arg1 = (Dali::Signal< void (float) > *)jarg1;
50740   {
50741     try {
50742       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50743     } catch (std::out_of_range& e) {
50744       {
50745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50746       };
50747     } catch (std::exception& e) {
50748       {
50749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50750       };
50751     } catch (Dali::DaliException e) {
50752       {
50753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50754       };
50755     } catch (...) {
50756       {
50757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50758       };
50759     }
50760   }
50761
50762   jresult = (unsigned long)result;
50763   return jresult;
50764 }
50765
50766
50767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50768   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50769   void (*arg2)(float) = (void (*)(float)) 0 ;
50770
50771   arg1 = (Dali::Signal< void (float) > *)jarg1;
50772   arg2 = (void (*)(float))jarg2;
50773   {
50774     try {
50775       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50776     } catch (std::out_of_range& e) {
50777       {
50778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50779       };
50780     } catch (std::exception& e) {
50781       {
50782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50783       };
50784     } catch (Dali::DaliException e) {
50785       {
50786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50787       };
50788     } catch (...) {
50789       {
50790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50791       };
50792     }
50793   }
50794
50795 }
50796
50797
50798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50799   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50800   void (*arg2)(float) = (void (*)(float)) 0 ;
50801
50802   arg1 = (Dali::Signal< void (float) > *)jarg1;
50803   arg2 = (void (*)(float))jarg2;
50804   {
50805     try {
50806       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50807     } catch (std::out_of_range& e) {
50808       {
50809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50810       };
50811     } catch (std::exception& e) {
50812       {
50813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50814       };
50815     } catch (Dali::DaliException e) {
50816       {
50817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50818       };
50819     } catch (...) {
50820       {
50821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50822       };
50823     }
50824   }
50825
50826 }
50827
50828
50829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50830   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50831   float arg2 ;
50832
50833   arg1 = (Dali::Signal< void (float) > *)jarg1;
50834   arg2 = (float)jarg2;
50835   {
50836     try {
50837       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50838     } catch (std::out_of_range& e) {
50839       {
50840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50841       };
50842     } catch (std::exception& e) {
50843       {
50844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50845       };
50846     } catch (Dali::DaliException e) {
50847       {
50848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50853       };
50854     }
50855   }
50856
50857 }
50858
50859
50860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50861   void * jresult ;
50862   Dali::Signal< void (float) > *result = 0 ;
50863
50864   {
50865     try {
50866       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50867     } catch (std::out_of_range& e) {
50868       {
50869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50870       };
50871     } catch (std::exception& e) {
50872       {
50873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50874       };
50875     } catch (Dali::DaliException e) {
50876       {
50877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50878       };
50879     } catch (...) {
50880       {
50881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50882       };
50883     }
50884   }
50885
50886   jresult = (void *)result;
50887   return jresult;
50888 }
50889
50890
50891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50892   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50893
50894   arg1 = (Dali::Signal< void (float) > *)jarg1;
50895   {
50896     try {
50897       delete arg1;
50898     } catch (std::out_of_range& e) {
50899       {
50900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50901       };
50902     } catch (std::exception& e) {
50903       {
50904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50905       };
50906     } catch (Dali::DaliException e) {
50907       {
50908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50909       };
50910     } catch (...) {
50911       {
50912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50913       };
50914     }
50915   }
50916
50917 }
50918
50919
50920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50921   unsigned int jresult ;
50922   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50923   bool result;
50924
50925   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50926   {
50927     try {
50928       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50929     } catch (std::out_of_range& e) {
50930       {
50931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50932       };
50933     } catch (std::exception& e) {
50934       {
50935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50936       };
50937     } catch (Dali::DaliException e) {
50938       {
50939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50940       };
50941     } catch (...) {
50942       {
50943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50944       };
50945     }
50946   }
50947
50948   jresult = result;
50949   return jresult;
50950 }
50951
50952
50953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50954   unsigned long jresult ;
50955   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50956   std::size_t result;
50957
50958   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50959   {
50960     try {
50961       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50962     } catch (std::out_of_range& e) {
50963       {
50964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50965       };
50966     } catch (std::exception& e) {
50967       {
50968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50969       };
50970     } catch (Dali::DaliException e) {
50971       {
50972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50973       };
50974     } catch (...) {
50975       {
50976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50977       };
50978     }
50979   }
50980
50981   jresult = (unsigned long)result;
50982   return jresult;
50983 }
50984
50985
50986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50987   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50988   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50989
50990   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50991   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50992   {
50993     try {
50994       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50995     } catch (std::out_of_range& e) {
50996       {
50997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (std::exception& e) {
51000       {
51001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51002       };
51003     } catch (Dali::DaliException e) {
51004       {
51005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51006       };
51007     } catch (...) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51010       };
51011     }
51012   }
51013
51014 }
51015
51016
51017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51018   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51019   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51020
51021   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51022   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51023   {
51024     try {
51025       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51026     } catch (std::out_of_range& e) {
51027       {
51028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51029       };
51030     } catch (std::exception& e) {
51031       {
51032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51033       };
51034     } catch (Dali::DaliException e) {
51035       {
51036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51037       };
51038     } catch (...) {
51039       {
51040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51041       };
51042     }
51043   }
51044
51045 }
51046
51047
51048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51049   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51050   Dali::BaseHandle arg2 ;
51051   Dali::BaseHandle *argp2 ;
51052
51053   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51054   argp2 = (Dali::BaseHandle *)jarg2;
51055   if (!argp2) {
51056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51057     return ;
51058   }
51059   arg2 = *argp2;
51060   {
51061     try {
51062       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51063     } catch (std::out_of_range& e) {
51064       {
51065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51066       };
51067     } catch (std::exception& e) {
51068       {
51069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51070       };
51071     } catch (Dali::DaliException e) {
51072       {
51073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51074       };
51075     } catch (...) {
51076       {
51077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51078       };
51079     }
51080   }
51081
51082 }
51083
51084
51085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51086   void * jresult ;
51087   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51088
51089   {
51090     try {
51091       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51092     } catch (std::out_of_range& e) {
51093       {
51094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51095       };
51096     } catch (std::exception& e) {
51097       {
51098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51099       };
51100     } catch (Dali::DaliException e) {
51101       {
51102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51103       };
51104     } catch (...) {
51105       {
51106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51107       };
51108     }
51109   }
51110
51111   jresult = (void *)result;
51112   return jresult;
51113 }
51114
51115
51116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51118
51119   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51120   {
51121     try {
51122       delete arg1;
51123     } catch (std::out_of_range& e) {
51124       {
51125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51126       };
51127     } catch (std::exception& e) {
51128       {
51129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51130       };
51131     } catch (Dali::DaliException e) {
51132       {
51133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51134       };
51135     } catch (...) {
51136       {
51137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51138       };
51139     }
51140   }
51141
51142 }
51143
51144
51145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51146   unsigned int jresult ;
51147   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51148   bool result;
51149
51150   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51151   {
51152     try {
51153       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51154     } catch (std::out_of_range& e) {
51155       {
51156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51157       };
51158     } catch (std::exception& e) {
51159       {
51160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51161       };
51162     } catch (Dali::DaliException e) {
51163       {
51164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51165       };
51166     } catch (...) {
51167       {
51168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51169       };
51170     }
51171   }
51172
51173   jresult = result;
51174   return jresult;
51175 }
51176
51177
51178 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51179   unsigned long jresult ;
51180   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51181   std::size_t result;
51182
51183   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51184   {
51185     try {
51186       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51187     } catch (std::out_of_range& e) {
51188       {
51189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51190       };
51191     } catch (std::exception& e) {
51192       {
51193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51194       };
51195     } catch (Dali::DaliException e) {
51196       {
51197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51202       };
51203     }
51204   }
51205
51206   jresult = (unsigned long)result;
51207   return jresult;
51208 }
51209
51210
51211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51212   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51213   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51214
51215   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51216   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51217   {
51218     try {
51219       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51220     } catch (std::out_of_range& e) {
51221       {
51222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51223       };
51224     } catch (std::exception& e) {
51225       {
51226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51227       };
51228     } catch (Dali::DaliException e) {
51229       {
51230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51231       };
51232     } catch (...) {
51233       {
51234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51235       };
51236     }
51237   }
51238
51239 }
51240
51241
51242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51243   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51244   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51245
51246   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51247   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51248   {
51249     try {
51250       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51251     } catch (std::out_of_range& e) {
51252       {
51253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51254       };
51255     } catch (std::exception& e) {
51256       {
51257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51258       };
51259     } catch (Dali::DaliException e) {
51260       {
51261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51262       };
51263     } catch (...) {
51264       {
51265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51266       };
51267     }
51268   }
51269
51270 }
51271
51272
51273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51274   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51275   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51276
51277   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51278   arg2 = (Dali::RefObject *)jarg2;
51279   {
51280     try {
51281       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51282     } catch (std::out_of_range& e) {
51283       {
51284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51285       };
51286     } catch (std::exception& e) {
51287       {
51288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51289       };
51290     } catch (Dali::DaliException e) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51293       };
51294     } catch (...) {
51295       {
51296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51297       };
51298     }
51299   }
51300
51301 }
51302
51303
51304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51305   void * jresult ;
51306   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51307
51308   {
51309     try {
51310       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51311     } catch (std::out_of_range& e) {
51312       {
51313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51314       };
51315     } catch (std::exception& e) {
51316       {
51317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51318       };
51319     } catch (Dali::DaliException e) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51322       };
51323     } catch (...) {
51324       {
51325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51326       };
51327     }
51328   }
51329
51330   jresult = (void *)result;
51331   return jresult;
51332 }
51333
51334
51335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51336   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51337
51338   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51339   {
51340     try {
51341       delete arg1;
51342     } catch (std::out_of_range& e) {
51343       {
51344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51345       };
51346     } catch (std::exception& e) {
51347       {
51348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51349       };
51350     } catch (Dali::DaliException e) {
51351       {
51352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51353       };
51354     } catch (...) {
51355       {
51356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51357       };
51358     }
51359   }
51360
51361 }
51362
51363
51364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51365   unsigned int jresult ;
51366   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51367   bool result;
51368
51369   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51370   {
51371     try {
51372       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51373     } catch (std::out_of_range& e) {
51374       {
51375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51376       };
51377     } catch (std::exception& e) {
51378       {
51379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51380       };
51381     } catch (Dali::DaliException e) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51384       };
51385     } catch (...) {
51386       {
51387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51388       };
51389     }
51390   }
51391
51392   jresult = result;
51393   return jresult;
51394 }
51395
51396
51397 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51398   unsigned long jresult ;
51399   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51400   std::size_t result;
51401
51402   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51403   {
51404     try {
51405       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51406     } catch (std::out_of_range& e) {
51407       {
51408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51409       };
51410     } catch (std::exception& e) {
51411       {
51412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51413       };
51414     } catch (Dali::DaliException e) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51417       };
51418     } catch (...) {
51419       {
51420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51421       };
51422     }
51423   }
51424
51425   jresult = (unsigned long)result;
51426   return jresult;
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51431   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51432   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51433
51434   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51435   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51436   {
51437     try {
51438       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51439     } catch (std::out_of_range& e) {
51440       {
51441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (std::exception& e) {
51444       {
51445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (Dali::DaliException e) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51450       };
51451     } catch (...) {
51452       {
51453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51454       };
51455     }
51456   }
51457
51458 }
51459
51460
51461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51462   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51463   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51464
51465   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51466   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51467   {
51468     try {
51469       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51470     } catch (std::out_of_range& e) {
51471       {
51472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51473       };
51474     } catch (std::exception& e) {
51475       {
51476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51477       };
51478     } catch (Dali::DaliException e) {
51479       {
51480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51481       };
51482     } catch (...) {
51483       {
51484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51485       };
51486     }
51487   }
51488
51489 }
51490
51491
51492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51493   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51494   Dali::PropertyNotification *arg2 = 0 ;
51495
51496   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51497   arg2 = (Dali::PropertyNotification *)jarg2;
51498   if (!arg2) {
51499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51500     return ;
51501   }
51502   {
51503     try {
51504       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51505     } catch (std::out_of_range& e) {
51506       {
51507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51508       };
51509     } catch (std::exception& e) {
51510       {
51511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51512       };
51513     } catch (Dali::DaliException e) {
51514       {
51515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51516       };
51517     } catch (...) {
51518       {
51519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51520       };
51521     }
51522   }
51523
51524 }
51525
51526
51527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51528   void * jresult ;
51529   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51530
51531   {
51532     try {
51533       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51534     } catch (std::out_of_range& e) {
51535       {
51536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51537       };
51538     } catch (std::exception& e) {
51539       {
51540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51541       };
51542     } catch (Dali::DaliException e) {
51543       {
51544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51545       };
51546     } catch (...) {
51547       {
51548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51549       };
51550     }
51551   }
51552
51553   jresult = (void *)result;
51554   return jresult;
51555 }
51556
51557
51558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51559   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51560
51561   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51562   {
51563     try {
51564       delete arg1;
51565     } catch (std::out_of_range& e) {
51566       {
51567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51568       };
51569     } catch (std::exception& e) {
51570       {
51571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51572       };
51573     } catch (Dali::DaliException e) {
51574       {
51575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51576       };
51577     } catch (...) {
51578       {
51579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51580       };
51581     }
51582   }
51583
51584 }
51585
51586
51587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51588   void * jresult ;
51589   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51590
51591   {
51592     try {
51593       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51594     } catch (std::out_of_range& e) {
51595       {
51596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51597       };
51598     } catch (std::exception& e) {
51599       {
51600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51601       };
51602     } catch (Dali::DaliException e) {
51603       {
51604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51605       };
51606     } catch (...) {
51607       {
51608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51609       };
51610     }
51611   }
51612
51613   jresult = (void *)result;
51614   return jresult;
51615 }
51616
51617
51618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51619   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51620
51621   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51622   {
51623     try {
51624       delete arg1;
51625     } catch (std::out_of_range& e) {
51626       {
51627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51628       };
51629     } catch (std::exception& e) {
51630       {
51631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51632       };
51633     } catch (Dali::DaliException e) {
51634       {
51635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51636       };
51637     } catch (...) {
51638       {
51639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51640       };
51641     }
51642   }
51643
51644 }
51645
51646
51647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51648   unsigned int jresult ;
51649   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51650   bool result;
51651
51652   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51653   {
51654     try {
51655       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);
51656     } catch (std::out_of_range& e) {
51657       {
51658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51659       };
51660     } catch (std::exception& e) {
51661       {
51662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51663       };
51664     } catch (Dali::DaliException e) {
51665       {
51666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51667       };
51668     } catch (...) {
51669       {
51670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51671       };
51672     }
51673   }
51674
51675   jresult = result;
51676   return jresult;
51677 }
51678
51679
51680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51681   unsigned long jresult ;
51682   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51683   std::size_t result;
51684
51685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51686   {
51687     try {
51688       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);
51689     } catch (std::out_of_range& e) {
51690       {
51691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51692       };
51693     } catch (std::exception& e) {
51694       {
51695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51696       };
51697     } catch (Dali::DaliException e) {
51698       {
51699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51700       };
51701     } catch (...) {
51702       {
51703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51704       };
51705     }
51706   }
51707
51708   jresult = (unsigned long)result;
51709   return jresult;
51710 }
51711
51712
51713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51714   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51715   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51716
51717   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51718   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51719   {
51720     try {
51721       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51722     } catch (std::out_of_range& e) {
51723       {
51724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51725       };
51726     } catch (std::exception& e) {
51727       {
51728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51729       };
51730     } catch (Dali::DaliException e) {
51731       {
51732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51733       };
51734     } catch (...) {
51735       {
51736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51737       };
51738     }
51739   }
51740
51741 }
51742
51743
51744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51745   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51746   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51747
51748   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51749   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51750   {
51751     try {
51752       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51753     } catch (std::out_of_range& e) {
51754       {
51755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51756       };
51757     } catch (std::exception& e) {
51758       {
51759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51760       };
51761     } catch (Dali::DaliException e) {
51762       {
51763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51764       };
51765     } catch (...) {
51766       {
51767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51768       };
51769     }
51770   }
51771
51772 }
51773
51774
51775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51776   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51777   Dali::Actor arg2 ;
51778   Dali::LongPressGesture *arg3 = 0 ;
51779   Dali::Actor *argp2 ;
51780
51781   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51782   argp2 = (Dali::Actor *)jarg2;
51783   if (!argp2) {
51784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51785     return ;
51786   }
51787   arg2 = *argp2;
51788   arg3 = (Dali::LongPressGesture *)jarg3;
51789   if (!arg3) {
51790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51791     return ;
51792   }
51793   {
51794     try {
51795       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51796     } catch (std::out_of_range& e) {
51797       {
51798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51799       };
51800     } catch (std::exception& e) {
51801       {
51802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51803       };
51804     } catch (Dali::DaliException e) {
51805       {
51806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51807       };
51808     } catch (...) {
51809       {
51810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51811       };
51812     }
51813   }
51814
51815 }
51816
51817
51818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51819   void * jresult ;
51820   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51821
51822   {
51823     try {
51824       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51825     } catch (std::out_of_range& e) {
51826       {
51827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51828       };
51829     } catch (std::exception& e) {
51830       {
51831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51832       };
51833     } catch (Dali::DaliException e) {
51834       {
51835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51836       };
51837     } catch (...) {
51838       {
51839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51840       };
51841     }
51842   }
51843
51844   jresult = (void *)result;
51845   return jresult;
51846 }
51847
51848
51849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51850   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51851
51852   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51853   {
51854     try {
51855       delete arg1;
51856     } catch (std::out_of_range& e) {
51857       {
51858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51859       };
51860     } catch (std::exception& e) {
51861       {
51862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51863       };
51864     } catch (Dali::DaliException e) {
51865       {
51866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51867       };
51868     } catch (...) {
51869       {
51870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51871       };
51872     }
51873   }
51874
51875 }
51876
51877
51878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51879   unsigned int jresult ;
51880   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51881   bool result;
51882
51883   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51884   {
51885     try {
51886       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);
51887     } catch (std::out_of_range& e) {
51888       {
51889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (std::exception& e) {
51892       {
51893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51894       };
51895     } catch (Dali::DaliException e) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51898       };
51899     } catch (...) {
51900       {
51901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51902       };
51903     }
51904   }
51905
51906   jresult = result;
51907   return jresult;
51908 }
51909
51910
51911 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51912   unsigned long jresult ;
51913   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51914   std::size_t result;
51915
51916   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51917   {
51918     try {
51919       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);
51920     } catch (std::out_of_range& e) {
51921       {
51922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51923       };
51924     } catch (std::exception& e) {
51925       {
51926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51927       };
51928     } catch (Dali::DaliException e) {
51929       {
51930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51931       };
51932     } catch (...) {
51933       {
51934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51935       };
51936     }
51937   }
51938
51939   jresult = (unsigned long)result;
51940   return jresult;
51941 }
51942
51943
51944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51945   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51946   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51947
51948   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51949   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51950   {
51951     try {
51952       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51953     } catch (std::out_of_range& e) {
51954       {
51955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (std::exception& e) {
51958       {
51959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (Dali::DaliException e) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51968       };
51969     }
51970   }
51971
51972 }
51973
51974
51975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51976   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51977   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51978
51979   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51980   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51981   {
51982     try {
51983       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51984     } catch (std::out_of_range& e) {
51985       {
51986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51987       };
51988     } catch (std::exception& e) {
51989       {
51990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51991       };
51992     } catch (Dali::DaliException e) {
51993       {
51994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51995       };
51996     } catch (...) {
51997       {
51998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51999       };
52000     }
52001   }
52002
52003 }
52004
52005
52006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52007   unsigned int jresult ;
52008   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52009   Dali::Actor arg2 ;
52010   Dali::TouchEvent *arg3 = 0 ;
52011   Dali::Actor *argp2 ;
52012   bool result;
52013
52014   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52015   argp2 = (Dali::Actor *)jarg2;
52016   if (!argp2) {
52017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52018     return 0;
52019   }
52020   arg2 = *argp2;
52021   arg3 = (Dali::TouchEvent *)jarg3;
52022   if (!arg3) {
52023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
52024     return 0;
52025   }
52026   {
52027     try {
52028       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
52029     } catch (std::out_of_range& e) {
52030       {
52031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52032       };
52033     } catch (std::exception& e) {
52034       {
52035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52036       };
52037     } catch (Dali::DaliException e) {
52038       {
52039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52040       };
52041     } catch (...) {
52042       {
52043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52044       };
52045     }
52046   }
52047
52048   jresult = result;
52049   return jresult;
52050 }
52051
52052
52053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52054   void * jresult ;
52055   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
52056
52057   {
52058     try {
52059       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
52060     } catch (std::out_of_range& e) {
52061       {
52062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52063       };
52064     } catch (std::exception& e) {
52065       {
52066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52067       };
52068     } catch (Dali::DaliException e) {
52069       {
52070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52071       };
52072     } catch (...) {
52073       {
52074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52075       };
52076     }
52077   }
52078
52079   jresult = (void *)result;
52080   return jresult;
52081 }
52082
52083
52084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52085   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
52086
52087   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
52088   {
52089     try {
52090       delete arg1;
52091     } catch (std::out_of_range& e) {
52092       {
52093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52094       };
52095     } catch (std::exception& e) {
52096       {
52097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52098       };
52099     } catch (Dali::DaliException e) {
52100       {
52101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52102       };
52103     } catch (...) {
52104       {
52105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52106       };
52107     }
52108   }
52109
52110 }
52111
52112
52113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52114   unsigned int jresult ;
52115   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52116   bool result;
52117
52118   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52119   {
52120     try {
52121       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);
52122     } catch (std::out_of_range& e) {
52123       {
52124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52125       };
52126     } catch (std::exception& e) {
52127       {
52128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52129       };
52130     } catch (Dali::DaliException e) {
52131       {
52132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52133       };
52134     } catch (...) {
52135       {
52136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52137       };
52138     }
52139   }
52140
52141   jresult = result;
52142   return jresult;
52143 }
52144
52145
52146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52147   unsigned long jresult ;
52148   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52149   std::size_t result;
52150
52151   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52152   {
52153     try {
52154       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);
52155     } catch (std::out_of_range& e) {
52156       {
52157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52158       };
52159     } catch (std::exception& e) {
52160       {
52161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52162       };
52163     } catch (Dali::DaliException e) {
52164       {
52165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52166       };
52167     } catch (...) {
52168       {
52169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52170       };
52171     }
52172   }
52173
52174   jresult = (unsigned long)result;
52175   return jresult;
52176 }
52177
52178
52179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52180   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52181   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52182
52183   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52184   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52185   {
52186     try {
52187       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52188     } catch (std::out_of_range& e) {
52189       {
52190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (std::exception& e) {
52193       {
52194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52195       };
52196     } catch (Dali::DaliException e) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52199       };
52200     } catch (...) {
52201       {
52202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52203       };
52204     }
52205   }
52206
52207 }
52208
52209
52210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52211   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52212   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52213
52214   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52215   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52216   {
52217     try {
52218       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52219     } catch (std::out_of_range& e) {
52220       {
52221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (std::exception& e) {
52224       {
52225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52226       };
52227     } catch (Dali::DaliException e) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52230       };
52231     } catch (...) {
52232       {
52233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52234       };
52235     }
52236   }
52237
52238 }
52239
52240
52241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52242   unsigned int jresult ;
52243   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52244   Dali::Actor arg2 ;
52245   Dali::HoverEvent *arg3 = 0 ;
52246   Dali::Actor *argp2 ;
52247   bool result;
52248
52249   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52250   argp2 = (Dali::Actor *)jarg2;
52251   if (!argp2) {
52252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52253     return 0;
52254   }
52255   arg2 = *argp2;
52256   arg3 = (Dali::HoverEvent *)jarg3;
52257   if (!arg3) {
52258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52259     return 0;
52260   }
52261   {
52262     try {
52263       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52264     } catch (std::out_of_range& e) {
52265       {
52266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52267       };
52268     } catch (std::exception& e) {
52269       {
52270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52271       };
52272     } catch (Dali::DaliException e) {
52273       {
52274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52275       };
52276     } catch (...) {
52277       {
52278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52279       };
52280     }
52281   }
52282
52283   jresult = result;
52284   return jresult;
52285 }
52286
52287
52288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52289   void * jresult ;
52290   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52291
52292   {
52293     try {
52294       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52295     } catch (std::out_of_range& e) {
52296       {
52297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52298       };
52299     } catch (std::exception& e) {
52300       {
52301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52302       };
52303     } catch (Dali::DaliException e) {
52304       {
52305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52306       };
52307     } catch (...) {
52308       {
52309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52310       };
52311     }
52312   }
52313
52314   jresult = (void *)result;
52315   return jresult;
52316 }
52317
52318
52319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52320   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52321
52322   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52323   {
52324     try {
52325       delete arg1;
52326     } catch (std::out_of_range& e) {
52327       {
52328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52329       };
52330     } catch (std::exception& e) {
52331       {
52332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52333       };
52334     } catch (Dali::DaliException e) {
52335       {
52336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52337       };
52338     } catch (...) {
52339       {
52340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52341       };
52342     }
52343   }
52344
52345 }
52346
52347
52348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52349   unsigned int jresult ;
52350   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52351   bool result;
52352
52353   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52354   {
52355     try {
52356       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);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52364       };
52365     } catch (Dali::DaliException e) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52368       };
52369     } catch (...) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52372       };
52373     }
52374   }
52375
52376   jresult = result;
52377   return jresult;
52378 }
52379
52380
52381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52382   unsigned long jresult ;
52383   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52384   std::size_t result;
52385
52386   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52387   {
52388     try {
52389       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);
52390     } catch (std::out_of_range& e) {
52391       {
52392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52393       };
52394     } catch (std::exception& e) {
52395       {
52396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52397       };
52398     } catch (Dali::DaliException e) {
52399       {
52400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52401       };
52402     } catch (...) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52405       };
52406     }
52407   }
52408
52409   jresult = (unsigned long)result;
52410   return jresult;
52411 }
52412
52413
52414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52415   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52416   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52417
52418   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52419   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52420   {
52421     try {
52422       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52423     } catch (std::out_of_range& e) {
52424       {
52425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (std::exception& e) {
52428       {
52429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52430       };
52431     } catch (Dali::DaliException e) {
52432       {
52433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52434       };
52435     } catch (...) {
52436       {
52437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52438       };
52439     }
52440   }
52441
52442 }
52443
52444
52445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52446   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52447   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52448
52449   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52450   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52451   {
52452     try {
52453       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52454     } catch (std::out_of_range& e) {
52455       {
52456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52457       };
52458     } catch (std::exception& e) {
52459       {
52460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52461       };
52462     } catch (Dali::DaliException e) {
52463       {
52464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52465       };
52466     } catch (...) {
52467       {
52468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52469       };
52470     }
52471   }
52472
52473 }
52474
52475
52476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52477   unsigned int jresult ;
52478   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52479   Dali::Actor arg2 ;
52480   Dali::WheelEvent *arg3 = 0 ;
52481   Dali::Actor *argp2 ;
52482   bool result;
52483
52484   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52485   argp2 = (Dali::Actor *)jarg2;
52486   if (!argp2) {
52487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52488     return 0;
52489   }
52490   arg2 = *argp2;
52491   arg3 = (Dali::WheelEvent *)jarg3;
52492   if (!arg3) {
52493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52494     return 0;
52495   }
52496   {
52497     try {
52498       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52499     } catch (std::out_of_range& e) {
52500       {
52501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52502       };
52503     } catch (std::exception& e) {
52504       {
52505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52506       };
52507     } catch (Dali::DaliException e) {
52508       {
52509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52510       };
52511     } catch (...) {
52512       {
52513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52514       };
52515     }
52516   }
52517
52518   jresult = result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52524   void * jresult ;
52525   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52526
52527   {
52528     try {
52529       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52530     } catch (std::out_of_range& e) {
52531       {
52532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (std::exception& e) {
52535       {
52536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (Dali::DaliException e) {
52539       {
52540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52541       };
52542     } catch (...) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52545       };
52546     }
52547   }
52548
52549   jresult = (void *)result;
52550   return jresult;
52551 }
52552
52553
52554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52555   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52556
52557   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52558   {
52559     try {
52560       delete arg1;
52561     } catch (std::out_of_range& e) {
52562       {
52563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52564       };
52565     } catch (std::exception& e) {
52566       {
52567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52568       };
52569     } catch (Dali::DaliException e) {
52570       {
52571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52572       };
52573     } catch (...) {
52574       {
52575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52576       };
52577     }
52578   }
52579
52580 }
52581
52582
52583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52584   unsigned int jresult ;
52585   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52586   bool result;
52587
52588   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52589   {
52590     try {
52591       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52592     } catch (std::out_of_range& e) {
52593       {
52594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52595       };
52596     } catch (std::exception& e) {
52597       {
52598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52599       };
52600     } catch (Dali::DaliException e) {
52601       {
52602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52603       };
52604     } catch (...) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52607       };
52608     }
52609   }
52610
52611   jresult = result;
52612   return jresult;
52613 }
52614
52615
52616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52617   unsigned long jresult ;
52618   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52619   std::size_t result;
52620
52621   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52622   {
52623     try {
52624       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52625     } catch (std::out_of_range& e) {
52626       {
52627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52628       };
52629     } catch (std::exception& e) {
52630       {
52631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52632       };
52633     } catch (Dali::DaliException e) {
52634       {
52635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52636       };
52637     } catch (...) {
52638       {
52639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52640       };
52641     }
52642   }
52643
52644   jresult = (unsigned long)result;
52645   return jresult;
52646 }
52647
52648
52649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52650   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52651   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52652
52653   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52654   arg2 = (void (*)(Dali::Actor))jarg2;
52655   {
52656     try {
52657       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52658     } catch (std::out_of_range& e) {
52659       {
52660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52661       };
52662     } catch (std::exception& e) {
52663       {
52664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52665       };
52666     } catch (Dali::DaliException e) {
52667       {
52668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52669       };
52670     } catch (...) {
52671       {
52672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52673       };
52674     }
52675   }
52676
52677 }
52678
52679
52680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52681   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52682   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52683
52684   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52685   arg2 = (void (*)(Dali::Actor))jarg2;
52686   {
52687     try {
52688       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52689     } catch (std::out_of_range& e) {
52690       {
52691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52692       };
52693     } catch (std::exception& e) {
52694       {
52695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52696       };
52697     } catch (Dali::DaliException e) {
52698       {
52699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52700       };
52701     } catch (...) {
52702       {
52703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52704       };
52705     }
52706   }
52707
52708 }
52709
52710
52711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52712   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52713   Dali::Actor arg2 ;
52714   Dali::Actor *argp2 ;
52715
52716   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52717   argp2 = (Dali::Actor *)jarg2;
52718   if (!argp2) {
52719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52720     return ;
52721   }
52722   arg2 = *argp2;
52723   {
52724     try {
52725       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52726     } catch (std::out_of_range& e) {
52727       {
52728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52729       };
52730     } catch (std::exception& e) {
52731       {
52732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (Dali::DaliException e) {
52735       {
52736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52737       };
52738     } catch (...) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52741       };
52742     }
52743   }
52744
52745 }
52746
52747
52748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52749   void * jresult ;
52750   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52751
52752   {
52753     try {
52754       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52755     } catch (std::out_of_range& e) {
52756       {
52757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52758       };
52759     } catch (std::exception& e) {
52760       {
52761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52762       };
52763     } catch (Dali::DaliException e) {
52764       {
52765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52766       };
52767     } catch (...) {
52768       {
52769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52770       };
52771     }
52772   }
52773
52774   jresult = (void *)result;
52775   return jresult;
52776 }
52777
52778
52779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52780   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52781
52782   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52783   {
52784     try {
52785       delete arg1;
52786     } catch (std::out_of_range& e) {
52787       {
52788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52789       };
52790     } catch (std::exception& e) {
52791       {
52792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52793       };
52794     } catch (Dali::DaliException e) {
52795       {
52796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52797       };
52798     } catch (...) {
52799       {
52800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52801       };
52802     }
52803   }
52804
52805 }
52806
52807
52808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52809   unsigned int jresult ;
52810   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52811   bool result;
52812
52813   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52814   {
52815     try {
52816       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52817     } catch (std::out_of_range& e) {
52818       {
52819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (std::exception& e) {
52822       {
52823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52824       };
52825     } catch (Dali::DaliException e) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52828       };
52829     } catch (...) {
52830       {
52831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52832       };
52833     }
52834   }
52835
52836   jresult = result;
52837   return jresult;
52838 }
52839
52840
52841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52842   unsigned long jresult ;
52843   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52844   std::size_t result;
52845
52846   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52847   {
52848     try {
52849       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52850     } catch (std::out_of_range& e) {
52851       {
52852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52853       };
52854     } catch (std::exception& e) {
52855       {
52856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52857       };
52858     } catch (Dali::DaliException e) {
52859       {
52860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52861       };
52862     } catch (...) {
52863       {
52864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52865       };
52866     }
52867   }
52868
52869   jresult = (unsigned long)result;
52870   return jresult;
52871 }
52872
52873
52874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52875   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52876   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52877
52878   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52879   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52880   {
52881     try {
52882       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52883     } catch (std::out_of_range& e) {
52884       {
52885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52886       };
52887     } catch (std::exception& e) {
52888       {
52889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52890       };
52891     } catch (Dali::DaliException e) {
52892       {
52893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52898       };
52899     }
52900   }
52901
52902 }
52903
52904
52905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52906   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52907   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52908
52909   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52910   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52911   {
52912     try {
52913       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52914     } catch (std::out_of_range& e) {
52915       {
52916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (std::exception& e) {
52919       {
52920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52921       };
52922     } catch (Dali::DaliException e) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52925       };
52926     } catch (...) {
52927       {
52928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52929       };
52930     }
52931   }
52932
52933 }
52934
52935
52936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52937   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52938   Dali::KeyEvent *arg2 = 0 ;
52939
52940   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52941   arg2 = (Dali::KeyEvent *)jarg2;
52942   if (!arg2) {
52943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52944     return ;
52945   }
52946   {
52947     try {
52948       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52949     } catch (std::out_of_range& e) {
52950       {
52951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52952       };
52953     } catch (std::exception& e) {
52954       {
52955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52956       };
52957     } catch (Dali::DaliException e) {
52958       {
52959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52960       };
52961     } catch (...) {
52962       {
52963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52964       };
52965     }
52966   }
52967
52968 }
52969
52970
52971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52972   void * jresult ;
52973   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52974
52975   {
52976     try {
52977       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52978     } catch (std::out_of_range& e) {
52979       {
52980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (std::exception& e) {
52983       {
52984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (Dali::DaliException e) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52989       };
52990     } catch (...) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52993       };
52994     }
52995   }
52996
52997   jresult = (void *)result;
52998   return jresult;
52999 }
53000
53001
53002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53003   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53004
53005   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53006   {
53007     try {
53008       delete arg1;
53009     } catch (std::out_of_range& e) {
53010       {
53011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (std::exception& e) {
53014       {
53015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53016       };
53017     } catch (Dali::DaliException e) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53020       };
53021     } catch (...) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53024       };
53025     }
53026   }
53027
53028 }
53029
53030
53031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53032   unsigned int jresult ;
53033   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53034   bool result;
53035
53036   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53037   {
53038     try {
53039       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53040     } catch (std::out_of_range& e) {
53041       {
53042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53043       };
53044     } catch (std::exception& e) {
53045       {
53046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (Dali::DaliException e) {
53049       {
53050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53055       };
53056     }
53057   }
53058
53059   jresult = result;
53060   return jresult;
53061 }
53062
53063
53064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53065   unsigned long jresult ;
53066   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53067   std::size_t result;
53068
53069   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53070   {
53071     try {
53072       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
53073     } catch (std::out_of_range& e) {
53074       {
53075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53076       };
53077     } catch (std::exception& e) {
53078       {
53079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53080       };
53081     } catch (Dali::DaliException e) {
53082       {
53083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53088       };
53089     }
53090   }
53091
53092   jresult = (unsigned long)result;
53093   return jresult;
53094 }
53095
53096
53097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53098   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53099   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53100
53101   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53102   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53103   {
53104     try {
53105       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53106     } catch (std::out_of_range& e) {
53107       {
53108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53109       };
53110     } catch (std::exception& e) {
53111       {
53112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53113       };
53114     } catch (Dali::DaliException e) {
53115       {
53116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53117       };
53118     } catch (...) {
53119       {
53120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53121       };
53122     }
53123   }
53124
53125 }
53126
53127
53128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53129   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53130   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
53131
53132   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53133   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
53134   {
53135     try {
53136       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53137     } catch (std::out_of_range& e) {
53138       {
53139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53140       };
53141     } catch (std::exception& e) {
53142       {
53143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53144       };
53145     } catch (Dali::DaliException e) {
53146       {
53147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53148       };
53149     } catch (...) {
53150       {
53151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53152       };
53153     }
53154   }
53155
53156 }
53157
53158
53159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53160   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53161   Dali::TouchEvent *arg2 = 0 ;
53162
53163   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53164   arg2 = (Dali::TouchEvent *)jarg2;
53165   if (!arg2) {
53166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53167     return ;
53168   }
53169   {
53170     try {
53171       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53172     } catch (std::out_of_range& e) {
53173       {
53174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53175       };
53176     } catch (std::exception& e) {
53177       {
53178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53179       };
53180     } catch (Dali::DaliException e) {
53181       {
53182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53183       };
53184     } catch (...) {
53185       {
53186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53187       };
53188     }
53189   }
53190
53191 }
53192
53193
53194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53195   void * jresult ;
53196   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53197
53198   {
53199     try {
53200       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53201     } catch (std::out_of_range& e) {
53202       {
53203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53204       };
53205     } catch (std::exception& e) {
53206       {
53207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53208       };
53209     } catch (Dali::DaliException e) {
53210       {
53211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53212       };
53213     } catch (...) {
53214       {
53215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53216       };
53217     }
53218   }
53219
53220   jresult = (void *)result;
53221   return jresult;
53222 }
53223
53224
53225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53226   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53227
53228   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53229   {
53230     try {
53231       delete arg1;
53232     } catch (std::out_of_range& e) {
53233       {
53234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53235       };
53236     } catch (std::exception& e) {
53237       {
53238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53239       };
53240     } catch (Dali::DaliException e) {
53241       {
53242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53243       };
53244     } catch (...) {
53245       {
53246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53247       };
53248     }
53249   }
53250
53251 }
53252
53253
53254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53255   unsigned int jresult ;
53256   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53257   bool result;
53258
53259   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53260   {
53261     try {
53262       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53263     } catch (std::out_of_range& e) {
53264       {
53265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53266       };
53267     } catch (std::exception& e) {
53268       {
53269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53270       };
53271     } catch (Dali::DaliException e) {
53272       {
53273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53274       };
53275     } catch (...) {
53276       {
53277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53278       };
53279     }
53280   }
53281
53282   jresult = result;
53283   return jresult;
53284 }
53285
53286
53287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53288   unsigned long jresult ;
53289   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53290   std::size_t result;
53291
53292   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53293   {
53294     try {
53295       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53296     } catch (std::out_of_range& e) {
53297       {
53298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53299       };
53300     } catch (std::exception& e) {
53301       {
53302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53303       };
53304     } catch (Dali::DaliException e) {
53305       {
53306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53307       };
53308     } catch (...) {
53309       {
53310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53311       };
53312     }
53313   }
53314
53315   jresult = (unsigned long)result;
53316   return jresult;
53317 }
53318
53319
53320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53321   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53322   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53323
53324   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53325   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53326   {
53327     try {
53328       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53329     } catch (std::out_of_range& e) {
53330       {
53331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53332       };
53333     } catch (std::exception& e) {
53334       {
53335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53336       };
53337     } catch (Dali::DaliException e) {
53338       {
53339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53340       };
53341     } catch (...) {
53342       {
53343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53344       };
53345     }
53346   }
53347
53348 }
53349
53350
53351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53352   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53353   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53354
53355   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53356   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53357   {
53358     try {
53359       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53360     } catch (std::out_of_range& e) {
53361       {
53362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53363       };
53364     } catch (std::exception& e) {
53365       {
53366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53367       };
53368     } catch (Dali::DaliException e) {
53369       {
53370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53371       };
53372     } catch (...) {
53373       {
53374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53375       };
53376     }
53377   }
53378
53379 }
53380
53381
53382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53383   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53384   Dali::WheelEvent *arg2 = 0 ;
53385
53386   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53387   arg2 = (Dali::WheelEvent *)jarg2;
53388   if (!arg2) {
53389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53390     return ;
53391   }
53392   {
53393     try {
53394       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53395     } catch (std::out_of_range& e) {
53396       {
53397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53398       };
53399     } catch (std::exception& e) {
53400       {
53401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53402       };
53403     } catch (Dali::DaliException e) {
53404       {
53405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53410       };
53411     }
53412   }
53413
53414 }
53415
53416
53417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53418   void * jresult ;
53419   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53420
53421   {
53422     try {
53423       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53424     } catch (std::out_of_range& e) {
53425       {
53426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53427       };
53428     } catch (std::exception& e) {
53429       {
53430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53431       };
53432     } catch (Dali::DaliException e) {
53433       {
53434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53435       };
53436     } catch (...) {
53437       {
53438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53439       };
53440     }
53441   }
53442
53443   jresult = (void *)result;
53444   return jresult;
53445 }
53446
53447
53448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53449   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53450
53451   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53452   {
53453     try {
53454       delete arg1;
53455     } catch (std::out_of_range& e) {
53456       {
53457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53458       };
53459     } catch (std::exception& e) {
53460       {
53461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53462       };
53463     } catch (Dali::DaliException e) {
53464       {
53465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53466       };
53467     } catch (...) {
53468       {
53469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53470       };
53471     }
53472   }
53473
53474 }
53475
53476
53477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53478   void * jresult ;
53479   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53480
53481   {
53482     try {
53483       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53484     } catch (std::out_of_range& e) {
53485       {
53486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53487       };
53488     } catch (std::exception& e) {
53489       {
53490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53491       };
53492     } catch (Dali::DaliException e) {
53493       {
53494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53495       };
53496     } catch (...) {
53497       {
53498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53499       };
53500     }
53501   }
53502
53503   jresult = (void *)result;
53504   return jresult;
53505 }
53506
53507
53508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53509   void * jresult ;
53510   Dali::Radian arg1 ;
53511   Dali::Radian arg2 ;
53512   Dali::Radian *argp1 ;
53513   Dali::Radian *argp2 ;
53514   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53515
53516   argp1 = (Dali::Radian *)jarg1;
53517   if (!argp1) {
53518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53519     return 0;
53520   }
53521   arg1 = *argp1;
53522   argp2 = (Dali::Radian *)jarg2;
53523   if (!argp2) {
53524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53525     return 0;
53526   }
53527   arg2 = *argp2;
53528   {
53529     try {
53530       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53531     } catch (std::out_of_range& e) {
53532       {
53533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53534       };
53535     } catch (std::exception& e) {
53536       {
53537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53538       };
53539     } catch (Dali::DaliException e) {
53540       {
53541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53542       };
53543     } catch (...) {
53544       {
53545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53546       };
53547     }
53548   }
53549
53550   jresult = (void *)result;
53551   return jresult;
53552 }
53553
53554
53555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53556   void * jresult ;
53557   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53558   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53559
53560   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53561   if (!arg1) {
53562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53563     return 0;
53564   }
53565   {
53566     try {
53567       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53568     } catch (std::out_of_range& e) {
53569       {
53570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53571       };
53572     } catch (std::exception& e) {
53573       {
53574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53575       };
53576     } catch (Dali::DaliException e) {
53577       {
53578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53579       };
53580     } catch (...) {
53581       {
53582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53583       };
53584     }
53585   }
53586
53587   jresult = (void *)result;
53588   return jresult;
53589 }
53590
53591
53592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53593   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53594   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53595
53596   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53597   arg2 = (Dali::Radian *)jarg2;
53598   if (arg1) (arg1)->first = *arg2;
53599 }
53600
53601
53602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53603   void * jresult ;
53604   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53605   Dali::Radian *result = 0 ;
53606
53607   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53608   result = (Dali::Radian *)& ((arg1)->first);
53609   jresult = (void *)result;
53610   return jresult;
53611 }
53612
53613
53614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53615   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53616   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53617
53618   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53619   arg2 = (Dali::Radian *)jarg2;
53620   if (arg1) (arg1)->second = *arg2;
53621 }
53622
53623
53624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53625   void * jresult ;
53626   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53627   Dali::Radian *result = 0 ;
53628
53629   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53630   result = (Dali::Radian *)& ((arg1)->second);
53631   jresult = (void *)result;
53632   return jresult;
53633 }
53634
53635
53636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53637   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53638
53639   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53640   {
53641     try {
53642       delete arg1;
53643     } catch (std::out_of_range& e) {
53644       {
53645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53646       };
53647     } catch (std::exception& e) {
53648       {
53649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53650       };
53651     } catch (Dali::DaliException e) {
53652       {
53653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53654       };
53655     } catch (...) {
53656       {
53657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53658       };
53659     }
53660   }
53661
53662 }
53663
53664
53665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53666   unsigned int jresult ;
53667   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53668   bool result;
53669
53670   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53671   {
53672     try {
53673       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);
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53681       };
53682     } catch (Dali::DaliException e) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53689       };
53690     }
53691   }
53692
53693   jresult = result;
53694   return jresult;
53695 }
53696
53697
53698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53699   unsigned long jresult ;
53700   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53701   std::size_t result;
53702
53703   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53704   {
53705     try {
53706       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);
53707     } catch (std::out_of_range& e) {
53708       {
53709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53710       };
53711     } catch (std::exception& e) {
53712       {
53713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53714       };
53715     } catch (Dali::DaliException e) {
53716       {
53717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53718       };
53719     } catch (...) {
53720       {
53721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53722       };
53723     }
53724   }
53725
53726   jresult = (unsigned long)result;
53727   return jresult;
53728 }
53729
53730
53731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53732   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53733   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53734
53735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53736   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53737   {
53738     try {
53739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53747       };
53748     } catch (Dali::DaliException e) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53751       };
53752     } catch (...) {
53753       {
53754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53755       };
53756     }
53757   }
53758
53759 }
53760
53761
53762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53763   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53764   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53765
53766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53767   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53768   {
53769     try {
53770       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53786       };
53787     }
53788   }
53789
53790 }
53791
53792
53793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53794   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53795   Dali::Actor arg2 ;
53796   Dali::PanGesture *arg3 = 0 ;
53797   Dali::Actor *argp2 ;
53798
53799   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53800   argp2 = (Dali::Actor *)jarg2;
53801   if (!argp2) {
53802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53803     return ;
53804   }
53805   arg2 = *argp2;
53806   arg3 = (Dali::PanGesture *)jarg3;
53807   if (!arg3) {
53808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53809     return ;
53810   }
53811   {
53812     try {
53813       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53814     } catch (std::out_of_range& e) {
53815       {
53816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53817       };
53818     } catch (std::exception& e) {
53819       {
53820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53821       };
53822     } catch (Dali::DaliException e) {
53823       {
53824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53825       };
53826     } catch (...) {
53827       {
53828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53829       };
53830     }
53831   }
53832
53833 }
53834
53835
53836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53837   void * jresult ;
53838   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53839
53840   {
53841     try {
53842       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53843     } catch (std::out_of_range& e) {
53844       {
53845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53846       };
53847     } catch (std::exception& e) {
53848       {
53849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53850       };
53851     } catch (Dali::DaliException e) {
53852       {
53853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53854       };
53855     } catch (...) {
53856       {
53857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53858       };
53859     }
53860   }
53861
53862   jresult = (void *)result;
53863   return jresult;
53864 }
53865
53866
53867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53868   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53869
53870   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53871   {
53872     try {
53873       delete arg1;
53874     } catch (std::out_of_range& e) {
53875       {
53876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53877       };
53878     } catch (std::exception& e) {
53879       {
53880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53881       };
53882     } catch (Dali::DaliException e) {
53883       {
53884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53885       };
53886     } catch (...) {
53887       {
53888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53889       };
53890     }
53891   }
53892
53893 }
53894
53895
53896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53897   unsigned int jresult ;
53898   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53899   bool result;
53900
53901   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53902   {
53903     try {
53904       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);
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53912       };
53913     } catch (Dali::DaliException e) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53916       };
53917     } catch (...) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53920       };
53921     }
53922   }
53923
53924   jresult = result;
53925   return jresult;
53926 }
53927
53928
53929 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53930   unsigned long jresult ;
53931   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53932   std::size_t result;
53933
53934   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53935   {
53936     try {
53937       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);
53938     } catch (std::out_of_range& e) {
53939       {
53940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53941       };
53942     } catch (std::exception& e) {
53943       {
53944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53945       };
53946     } catch (Dali::DaliException e) {
53947       {
53948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53949       };
53950     } catch (...) {
53951       {
53952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53953       };
53954     }
53955   }
53956
53957   jresult = (unsigned long)result;
53958   return jresult;
53959 }
53960
53961
53962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53963   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53964   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53965
53966   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53967   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53968   {
53969     try {
53970       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53971     } catch (std::out_of_range& e) {
53972       {
53973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53974       };
53975     } catch (std::exception& e) {
53976       {
53977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53978       };
53979     } catch (Dali::DaliException e) {
53980       {
53981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53982       };
53983     } catch (...) {
53984       {
53985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53986       };
53987     }
53988   }
53989
53990 }
53991
53992
53993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53994   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53995   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53996
53997   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53998   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53999   {
54000     try {
54001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54002     } catch (std::out_of_range& e) {
54003       {
54004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54005       };
54006     } catch (std::exception& e) {
54007       {
54008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54009       };
54010     } catch (Dali::DaliException e) {
54011       {
54012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54013       };
54014     } catch (...) {
54015       {
54016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54017       };
54018     }
54019   }
54020
54021 }
54022
54023
54024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54025   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54026   Dali::Actor arg2 ;
54027   Dali::PinchGesture *arg3 = 0 ;
54028   Dali::Actor *argp2 ;
54029
54030   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54031   argp2 = (Dali::Actor *)jarg2;
54032   if (!argp2) {
54033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54034     return ;
54035   }
54036   arg2 = *argp2;
54037   arg3 = (Dali::PinchGesture *)jarg3;
54038   if (!arg3) {
54039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54040     return ;
54041   }
54042   {
54043     try {
54044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54045     } catch (std::out_of_range& e) {
54046       {
54047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54048       };
54049     } catch (std::exception& e) {
54050       {
54051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54052       };
54053     } catch (Dali::DaliException e) {
54054       {
54055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54056       };
54057     } catch (...) {
54058       {
54059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54060       };
54061     }
54062   }
54063
54064 }
54065
54066
54067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54068   void * jresult ;
54069   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54070
54071   {
54072     try {
54073       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54074     } catch (std::out_of_range& e) {
54075       {
54076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54077       };
54078     } catch (std::exception& e) {
54079       {
54080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54081       };
54082     } catch (Dali::DaliException e) {
54083       {
54084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54085       };
54086     } catch (...) {
54087       {
54088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54089       };
54090     }
54091   }
54092
54093   jresult = (void *)result;
54094   return jresult;
54095 }
54096
54097
54098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54099   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54100
54101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54102   {
54103     try {
54104       delete arg1;
54105     } catch (std::out_of_range& e) {
54106       {
54107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54108       };
54109     } catch (std::exception& e) {
54110       {
54111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54112       };
54113     } catch (Dali::DaliException e) {
54114       {
54115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54116       };
54117     } catch (...) {
54118       {
54119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54120       };
54121     }
54122   }
54123
54124 }
54125
54126
54127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54128   unsigned int jresult ;
54129   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54130   bool result;
54131
54132   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54133   {
54134     try {
54135       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);
54136     } catch (std::out_of_range& e) {
54137       {
54138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54139       };
54140     } catch (std::exception& e) {
54141       {
54142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54143       };
54144     } catch (Dali::DaliException e) {
54145       {
54146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54147       };
54148     } catch (...) {
54149       {
54150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54151       };
54152     }
54153   }
54154
54155   jresult = result;
54156   return jresult;
54157 }
54158
54159
54160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54161   unsigned long jresult ;
54162   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54163   std::size_t result;
54164
54165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54166   {
54167     try {
54168       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);
54169     } catch (std::out_of_range& e) {
54170       {
54171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54172       };
54173     } catch (std::exception& e) {
54174       {
54175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54176       };
54177     } catch (Dali::DaliException e) {
54178       {
54179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54180       };
54181     } catch (...) {
54182       {
54183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54184       };
54185     }
54186   }
54187
54188   jresult = (unsigned long)result;
54189   return jresult;
54190 }
54191
54192
54193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54194   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54195   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54196
54197   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54198   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54199   {
54200     try {
54201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54202     } catch (std::out_of_range& e) {
54203       {
54204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54205       };
54206     } catch (std::exception& e) {
54207       {
54208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54209       };
54210     } catch (Dali::DaliException e) {
54211       {
54212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54213       };
54214     } catch (...) {
54215       {
54216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54217       };
54218     }
54219   }
54220
54221 }
54222
54223
54224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54225   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54226   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54227
54228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54229   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54230   {
54231     try {
54232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54233     } catch (std::out_of_range& e) {
54234       {
54235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54236       };
54237     } catch (std::exception& e) {
54238       {
54239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54240       };
54241     } catch (Dali::DaliException e) {
54242       {
54243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54244       };
54245     } catch (...) {
54246       {
54247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54248       };
54249     }
54250   }
54251
54252 }
54253
54254
54255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54256   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54257   Dali::Actor arg2 ;
54258   Dali::TapGesture *arg3 = 0 ;
54259   Dali::Actor *argp2 ;
54260
54261   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54262   argp2 = (Dali::Actor *)jarg2;
54263   if (!argp2) {
54264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54265     return ;
54266   }
54267   arg2 = *argp2;
54268   arg3 = (Dali::TapGesture *)jarg3;
54269   if (!arg3) {
54270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54271     return ;
54272   }
54273   {
54274     try {
54275       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54276     } catch (std::out_of_range& e) {
54277       {
54278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54279       };
54280     } catch (std::exception& e) {
54281       {
54282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54283       };
54284     } catch (Dali::DaliException e) {
54285       {
54286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54287       };
54288     } catch (...) {
54289       {
54290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54291       };
54292     }
54293   }
54294
54295 }
54296
54297
54298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54299   void * jresult ;
54300   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54301
54302   {
54303     try {
54304       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54305     } catch (std::out_of_range& e) {
54306       {
54307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54308       };
54309     } catch (std::exception& e) {
54310       {
54311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (Dali::DaliException e) {
54314       {
54315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54316       };
54317     } catch (...) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54320       };
54321     }
54322   }
54323
54324   jresult = (void *)result;
54325   return jresult;
54326 }
54327
54328
54329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54330   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54331
54332   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54333   {
54334     try {
54335       delete arg1;
54336     } catch (std::out_of_range& e) {
54337       {
54338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54339       };
54340     } catch (std::exception& e) {
54341       {
54342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54343       };
54344     } catch (Dali::DaliException e) {
54345       {
54346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54347       };
54348     } catch (...) {
54349       {
54350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54351       };
54352     }
54353   }
54354
54355 }
54356
54357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54358   unsigned int jresult ;
54359   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54360   bool result = false;
54361
54362   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54363   {
54364     try {
54365       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);
54366     } catch (std::out_of_range& e) {
54367       {
54368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54369       };
54370     } catch (std::exception& e) {
54371       {
54372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54373       };
54374     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54375   }
54376   jresult = result;
54377   return jresult;
54378 }
54379
54380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54381   unsigned long jresult ;
54382   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54383   std::size_t result = 0;
54384
54385   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54386   {
54387     try {
54388       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);
54389     } catch (std::out_of_range& e) {
54390       {
54391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54392       };
54393     } catch (std::exception& e) {
54394       {
54395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54396       };
54397     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54398   }
54399   jresult = (unsigned long)result;
54400   return jresult;
54401 }
54402
54403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54404   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54405   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54406
54407   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54408   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54409   {
54410     try {
54411       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54412     } catch (std::out_of_range& e) {
54413       {
54414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54415       };
54416     } catch (std::exception& e) {
54417       {
54418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54419       };
54420     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54421   }
54422 }
54423
54424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54425   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54426   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54427
54428   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54429   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54430   {
54431     try {
54432       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54433     } catch (std::out_of_range& e) {
54434       {
54435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54436       };
54437     } catch (std::exception& e) {
54438       {
54439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54440       };
54441     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54442   }
54443 }
54444
54445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54446   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54447   Dali::Actor arg2 ;
54448   //bool arg3 ;
54449   Dali::LayoutDirection::Type arg4 ;
54450   Dali::Actor *argp2 ;
54451
54452   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54453   argp2 = (Dali::Actor *)jarg2;
54454   if (!argp2) {
54455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54456     return ;
54457   }
54458   arg2 = *argp2;
54459   //arg3 = jarg3 ? true : false;
54460   arg4 = (Dali::LayoutDirection::Type)jarg4;
54461   {
54462     try {
54463       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54464     } catch (std::out_of_range& e) {
54465       {
54466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54467       };
54468     } catch (std::exception& e) {
54469       {
54470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54471       };
54472     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54473   }
54474 }
54475
54476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54477   void * jresult ;
54478   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54479
54480   {
54481     try {
54482       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54483     } catch (std::out_of_range& e) {
54484       {
54485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54486       };
54487     } catch (std::exception& e) {
54488       {
54489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54492   }
54493   jresult = (void *)result;
54494   return jresult;
54495 }
54496
54497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54498   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54499
54500   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54501   {
54502     try {
54503       delete arg1;
54504     } catch (std::out_of_range& e) {
54505       {
54506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54507       };
54508     } catch (std::exception& e) {
54509       {
54510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54511       };
54512     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54513   }
54514 }
54515
54516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54517   unsigned int jresult ;
54518   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54519   bool result;
54520
54521   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54522   {
54523     try {
54524       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);
54525     } catch (std::out_of_range& e) {
54526       {
54527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54528       };
54529     } catch (std::exception& e) {
54530       {
54531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54532       };
54533     } catch (Dali::DaliException e) {
54534       {
54535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54536       };
54537     } catch (...) {
54538       {
54539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54540       };
54541     }
54542   }
54543
54544   jresult = result;
54545   return jresult;
54546 }
54547
54548
54549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54550   unsigned long jresult ;
54551   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54552   std::size_t result;
54553
54554   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54555   {
54556     try {
54557       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);
54558     } catch (std::out_of_range& e) {
54559       {
54560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54561       };
54562     } catch (std::exception& e) {
54563       {
54564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (Dali::DaliException e) {
54567       {
54568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54573       };
54574     }
54575   }
54576
54577   jresult = (unsigned long)result;
54578   return jresult;
54579 }
54580
54581
54582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54583   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54584   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54585
54586   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54587   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54588   {
54589     try {
54590       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54591     } catch (std::out_of_range& e) {
54592       {
54593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54594       };
54595     } catch (std::exception& e) {
54596       {
54597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54598       };
54599     } catch (Dali::DaliException e) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54602       };
54603     } catch (...) {
54604       {
54605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54606       };
54607     }
54608   }
54609
54610 }
54611
54612
54613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54614   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54615   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54616
54617   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54618   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54619   {
54620     try {
54621       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54622     } catch (std::out_of_range& e) {
54623       {
54624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54625       };
54626     } catch (std::exception& e) {
54627       {
54628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54629       };
54630     } catch (Dali::DaliException e) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54633       };
54634     } catch (...) {
54635       {
54636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54637       };
54638     }
54639   }
54640
54641 }
54642
54643
54644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54645   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54646   Dali::Actor arg2 ;
54647   bool arg3 ;
54648   Dali::DevelActor::VisibilityChange::Type arg4 ;
54649   Dali::Actor *argp2 ;
54650
54651   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54652   argp2 = (Dali::Actor *)jarg2;
54653   if (!argp2) {
54654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54655     return ;
54656   }
54657   arg2 = *argp2;
54658   arg3 = jarg3 ? true : false;
54659   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54660   {
54661     try {
54662       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54663     } catch (std::out_of_range& e) {
54664       {
54665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54666       };
54667     } catch (std::exception& e) {
54668       {
54669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54670       };
54671     } catch (Dali::DaliException e) {
54672       {
54673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54674       };
54675     } catch (...) {
54676       {
54677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54678       };
54679     }
54680   }
54681
54682 }
54683
54684
54685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54686   void * jresult ;
54687   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54688
54689   {
54690     try {
54691       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54692     } catch (std::out_of_range& e) {
54693       {
54694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54695       };
54696     } catch (std::exception& e) {
54697       {
54698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (Dali::DaliException e) {
54701       {
54702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54703       };
54704     } catch (...) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54707       };
54708     }
54709   }
54710
54711   jresult = (void *)result;
54712   return jresult;
54713 }
54714
54715
54716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54717   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54718
54719   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54720   {
54721     try {
54722       delete arg1;
54723     } catch (std::out_of_range& e) {
54724       {
54725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54726       };
54727     } catch (std::exception& e) {
54728       {
54729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54730       };
54731     } catch (Dali::DaliException e) {
54732       {
54733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54734       };
54735     } catch (...) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54738       };
54739     }
54740   }
54741
54742 }
54743
54744
54745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54746   void * jresult ;
54747   Dali::Timer *result = 0 ;
54748
54749   {
54750     try {
54751       result = (Dali::Timer *)new Dali::Timer();
54752     } catch (std::out_of_range& e) {
54753       {
54754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54755       };
54756     } catch (std::exception& e) {
54757       {
54758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54759       };
54760     } catch (Dali::DaliException e) {
54761       {
54762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54763       };
54764     } catch (...) {
54765       {
54766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54767       };
54768     }
54769   }
54770
54771   jresult = (void *)result;
54772   return jresult;
54773 }
54774
54775
54776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54777   void * jresult ;
54778   unsigned int arg1 ;
54779   Dali::Timer result;
54780
54781   arg1 = (unsigned int)jarg1;
54782   {
54783     try {
54784       result = Dali::Timer::New(arg1);
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (Dali::DaliException e) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54796       };
54797     } catch (...) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54800       };
54801     }
54802   }
54803
54804   jresult = new Dali::Timer((const Dali::Timer &)result);
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54810   void * jresult ;
54811   Dali::Timer *arg1 = 0 ;
54812   Dali::Timer *result = 0 ;
54813
54814   arg1 = (Dali::Timer *)jarg1;
54815   if (!arg1) {
54816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54817     return 0;
54818   }
54819   {
54820     try {
54821       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54822     } catch (std::out_of_range& e) {
54823       {
54824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54825       };
54826     } catch (std::exception& e) {
54827       {
54828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54829       };
54830     } catch (Dali::DaliException e) {
54831       {
54832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54833       };
54834     } catch (...) {
54835       {
54836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54837       };
54838     }
54839   }
54840
54841   jresult = (void *)result;
54842   return jresult;
54843 }
54844
54845
54846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54847   void * jresult ;
54848   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54849   Dali::Timer *arg2 = 0 ;
54850   Dali::Timer *result = 0 ;
54851
54852   arg1 = (Dali::Timer *)jarg1;
54853   arg2 = (Dali::Timer *)jarg2;
54854   if (!arg2) {
54855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54856     return 0;
54857   }
54858   {
54859     try {
54860       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54861     } catch (std::out_of_range& e) {
54862       {
54863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54864       };
54865     } catch (std::exception& e) {
54866       {
54867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54868       };
54869     } catch (Dali::DaliException e) {
54870       {
54871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54872       };
54873     } catch (...) {
54874       {
54875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54876       };
54877     }
54878   }
54879
54880   jresult = (void *)result;
54881   return jresult;
54882 }
54883
54884
54885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54886   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54887
54888   arg1 = (Dali::Timer *)jarg1;
54889   {
54890     try {
54891       delete arg1;
54892     } catch (std::out_of_range& e) {
54893       {
54894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54895       };
54896     } catch (std::exception& e) {
54897       {
54898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (Dali::DaliException e) {
54901       {
54902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54907       };
54908     }
54909   }
54910
54911 }
54912
54913
54914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54915   void * jresult ;
54916   Dali::BaseHandle arg1 ;
54917   Dali::BaseHandle *argp1 ;
54918   Dali::Timer result;
54919
54920   argp1 = (Dali::BaseHandle *)jarg1;
54921   if (!argp1) {
54922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54923     return 0;
54924   }
54925   arg1 = *argp1;
54926   {
54927     try {
54928       result = Dali::Timer::DownCast(arg1);
54929     } catch (std::out_of_range& e) {
54930       {
54931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54932       };
54933     } catch (std::exception& e) {
54934       {
54935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54936       };
54937     } catch (Dali::DaliException e) {
54938       {
54939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54940       };
54941     } catch (...) {
54942       {
54943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54944       };
54945     }
54946   }
54947
54948   jresult = new Dali::Timer((const Dali::Timer &)result);
54949   return jresult;
54950 }
54951
54952
54953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54954   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54955
54956   arg1 = (Dali::Timer *)jarg1;
54957   {
54958     try {
54959       (arg1)->Start();
54960     } catch (std::out_of_range& e) {
54961       {
54962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54963       };
54964     } catch (std::exception& e) {
54965       {
54966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54967       };
54968     } catch (Dali::DaliException e) {
54969       {
54970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54971       };
54972     } catch (...) {
54973       {
54974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54975       };
54976     }
54977   }
54978
54979 }
54980
54981
54982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54983   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54984
54985   arg1 = (Dali::Timer *)jarg1;
54986   {
54987     try {
54988       (arg1)->Stop();
54989     } catch (std::out_of_range& e) {
54990       {
54991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54992       };
54993     } catch (std::exception& e) {
54994       {
54995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54996       };
54997     } catch (Dali::DaliException e) {
54998       {
54999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55000       };
55001     } catch (...) {
55002       {
55003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55004       };
55005     }
55006   }
55007
55008 }
55009
55010
55011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55012   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55013   unsigned int arg2 ;
55014
55015   arg1 = (Dali::Timer *)jarg1;
55016   arg2 = (unsigned int)jarg2;
55017   {
55018     try {
55019       (arg1)->SetInterval(arg2);
55020     } catch (std::out_of_range& e) {
55021       {
55022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55023       };
55024     } catch (std::exception& e) {
55025       {
55026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55027       };
55028     } catch (Dali::DaliException e) {
55029       {
55030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55031       };
55032     } catch (...) {
55033       {
55034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55035       };
55036     }
55037   }
55038
55039 }
55040
55041
55042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55043   unsigned int jresult ;
55044   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55045   unsigned int result;
55046
55047   arg1 = (Dali::Timer *)jarg1;
55048   {
55049     try {
55050       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55051     } catch (std::out_of_range& e) {
55052       {
55053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55054       };
55055     } catch (std::exception& e) {
55056       {
55057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55058       };
55059     } catch (Dali::DaliException e) {
55060       {
55061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55062       };
55063     } catch (...) {
55064       {
55065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55066       };
55067     }
55068   }
55069
55070   jresult = result;
55071   return jresult;
55072 }
55073
55074
55075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55076   unsigned int jresult ;
55077   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55078   bool result;
55079
55080   arg1 = (Dali::Timer *)jarg1;
55081   {
55082     try {
55083       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55084     } catch (std::out_of_range& e) {
55085       {
55086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55087       };
55088     } catch (std::exception& e) {
55089       {
55090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55091       };
55092     } catch (Dali::DaliException e) {
55093       {
55094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55095       };
55096     } catch (...) {
55097       {
55098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55099       };
55100     }
55101   }
55102
55103   jresult = result;
55104   return jresult;
55105 }
55106
55107
55108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55109   void * jresult ;
55110   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55111   Dali::Timer::TimerSignalType *result = 0 ;
55112
55113   arg1 = (Dali::Timer *)jarg1;
55114   {
55115     try {
55116       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55117     } catch (std::out_of_range& e) {
55118       {
55119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55120       };
55121     } catch (std::exception& e) {
55122       {
55123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55124       };
55125     } catch (Dali::DaliException e) {
55126       {
55127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55128       };
55129     } catch (...) {
55130       {
55131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55132       };
55133     }
55134   }
55135
55136   jresult = (void *)result;
55137   return jresult;
55138 }
55139
55140
55141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55142   unsigned int jresult ;
55143   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55144   bool result;
55145
55146   arg1 = (Dali::Signal< bool () > *)jarg1;
55147   {
55148     try {
55149       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55150     } catch (std::out_of_range& e) {
55151       {
55152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55153       };
55154     } catch (std::exception& e) {
55155       {
55156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55157       };
55158     } catch (Dali::DaliException e) {
55159       {
55160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55161       };
55162     } catch (...) {
55163       {
55164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55165       };
55166     }
55167   }
55168
55169   jresult = result;
55170   return jresult;
55171 }
55172
55173
55174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55175   unsigned long jresult ;
55176   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55177   std::size_t result;
55178
55179   arg1 = (Dali::Signal< bool () > *)jarg1;
55180   {
55181     try {
55182       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55183     } catch (std::out_of_range& e) {
55184       {
55185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55186       };
55187     } catch (std::exception& e) {
55188       {
55189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55190       };
55191     } catch (Dali::DaliException e) {
55192       {
55193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55194       };
55195     } catch (...) {
55196       {
55197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55198       };
55199     }
55200   }
55201
55202   jresult = (unsigned long)result;
55203   return jresult;
55204 }
55205
55206
55207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55208   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55209   bool (*arg2)() = (bool (*)()) 0 ;
55210
55211   arg1 = (Dali::Signal< bool () > *)jarg1;
55212   arg2 = (bool (*)())jarg2;
55213   {
55214     try {
55215       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55216     } catch (std::out_of_range& e) {
55217       {
55218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55219       };
55220     } catch (std::exception& e) {
55221       {
55222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55223       };
55224     } catch (Dali::DaliException e) {
55225       {
55226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55227       };
55228     } catch (...) {
55229       {
55230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55231       };
55232     }
55233   }
55234
55235 }
55236
55237
55238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55239   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55240   bool (*arg2)() = (bool (*)()) 0 ;
55241
55242   arg1 = (Dali::Signal< bool () > *)jarg1;
55243   arg2 = (bool (*)())jarg2;
55244   {
55245     try {
55246       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55247     } catch (std::out_of_range& e) {
55248       {
55249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55250       };
55251     } catch (std::exception& e) {
55252       {
55253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55254       };
55255     } catch (Dali::DaliException e) {
55256       {
55257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55258       };
55259     } catch (...) {
55260       {
55261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55262       };
55263     }
55264   }
55265
55266 }
55267
55268
55269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55270   unsigned int jresult ;
55271   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55272   bool result;
55273
55274   arg1 = (Dali::Signal< bool () > *)jarg1;
55275   {
55276     try {
55277       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55278     } catch (std::out_of_range& e) {
55279       {
55280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55281       };
55282     } catch (std::exception& e) {
55283       {
55284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55285       };
55286     } catch (Dali::DaliException e) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55289       };
55290     } catch (...) {
55291       {
55292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55293       };
55294     }
55295   }
55296
55297   jresult = result;
55298   return jresult;
55299 }
55300
55301
55302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55303   void * jresult ;
55304   Dali::Signal< bool () > *result = 0 ;
55305
55306   {
55307     try {
55308       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55309     } catch (std::out_of_range& e) {
55310       {
55311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55312       };
55313     } catch (std::exception& e) {
55314       {
55315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55316       };
55317     } catch (Dali::DaliException e) {
55318       {
55319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55320       };
55321     } catch (...) {
55322       {
55323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55324       };
55325     }
55326   }
55327
55328   jresult = (void *)result;
55329   return jresult;
55330 }
55331
55332
55333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55334   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55335
55336   arg1 = (Dali::Signal< bool () > *)jarg1;
55337   {
55338     try {
55339       delete arg1;
55340     } catch (std::out_of_range& e) {
55341       {
55342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55343       };
55344     } catch (std::exception& e) {
55345       {
55346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55347       };
55348     } catch (Dali::DaliException e) {
55349       {
55350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55351       };
55352     } catch (...) {
55353       {
55354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55355       };
55356     }
55357   }
55358
55359 }
55360
55361
55362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55363   int jresult ;
55364   int result;
55365
55366   {
55367     try {
55368       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55369     } catch (std::out_of_range& e) {
55370       {
55371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55372       };
55373     } catch (std::exception& e) {
55374       {
55375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55376       };
55377     } catch (Dali::DaliException e) {
55378       {
55379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55380       };
55381     } catch (...) {
55382       {
55383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55384       };
55385     }
55386   }
55387
55388   jresult = (int)result;
55389   return jresult;
55390 }
55391
55392
55393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55394   int jresult ;
55395   int result;
55396
55397   {
55398     try {
55399       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55400     } catch (std::out_of_range& e) {
55401       {
55402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55403       };
55404     } catch (std::exception& e) {
55405       {
55406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55407       };
55408     } catch (Dali::DaliException e) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55411       };
55412     } catch (...) {
55413       {
55414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55415       };
55416     }
55417   }
55418
55419   jresult = (int)result;
55420   return jresult;
55421 }
55422
55423
55424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55425   int jresult ;
55426   int result;
55427
55428   {
55429     try {
55430       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55431     } catch (std::out_of_range& e) {
55432       {
55433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55434       };
55435     } catch (std::exception& e) {
55436       {
55437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (Dali::DaliException e) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55442       };
55443     } catch (...) {
55444       {
55445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55446       };
55447     }
55448   }
55449
55450   jresult = (int)result;
55451   return jresult;
55452 }
55453
55454
55455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55456   int jresult ;
55457   int result;
55458
55459   {
55460     try {
55461       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55462     } catch (std::out_of_range& e) {
55463       {
55464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55465       };
55466     } catch (std::exception& e) {
55467       {
55468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55469       };
55470     } catch (Dali::DaliException e) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55473       };
55474     } catch (...) {
55475       {
55476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55477       };
55478     }
55479   }
55480
55481   jresult = (int)result;
55482   return jresult;
55483 }
55484
55485
55486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55487   int jresult ;
55488   int result;
55489
55490   {
55491     try {
55492       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55493     } catch (std::out_of_range& e) {
55494       {
55495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55496       };
55497     } catch (std::exception& e) {
55498       {
55499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55500       };
55501     } catch (Dali::DaliException e) {
55502       {
55503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55504       };
55505     } catch (...) {
55506       {
55507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55508       };
55509     }
55510   }
55511
55512   jresult = (int)result;
55513   return jresult;
55514 }
55515
55516
55517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55518   int jresult ;
55519   int result;
55520
55521   {
55522     try {
55523       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55524     } catch (std::out_of_range& e) {
55525       {
55526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55527       };
55528     } catch (std::exception& e) {
55529       {
55530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55531       };
55532     } catch (Dali::DaliException e) {
55533       {
55534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55535       };
55536     } catch (...) {
55537       {
55538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55539       };
55540     }
55541   }
55542
55543   jresult = (int)result;
55544   return jresult;
55545 }
55546
55547
55548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55549   int jresult ;
55550   int result;
55551
55552   {
55553     try {
55554       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55555     } catch (std::out_of_range& e) {
55556       {
55557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55558       };
55559     } catch (std::exception& e) {
55560       {
55561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55562       };
55563     } catch (Dali::DaliException e) {
55564       {
55565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55566       };
55567     } catch (...) {
55568       {
55569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55570       };
55571     }
55572   }
55573
55574   jresult = (int)result;
55575   return jresult;
55576 }
55577
55578
55579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55580   int jresult ;
55581   int result;
55582
55583   {
55584     try {
55585       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55586     } catch (std::out_of_range& e) {
55587       {
55588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55589       };
55590     } catch (std::exception& e) {
55591       {
55592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55593       };
55594     } catch (Dali::DaliException e) {
55595       {
55596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55597       };
55598     } catch (...) {
55599       {
55600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55601       };
55602     }
55603   }
55604
55605   jresult = (int)result;
55606   return jresult;
55607 }
55608
55609
55610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55611   int jresult ;
55612   int result;
55613
55614   {
55615     try {
55616       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55617     } catch (std::out_of_range& e) {
55618       {
55619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55620       };
55621     } catch (std::exception& e) {
55622       {
55623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55624       };
55625     } catch (Dali::DaliException e) {
55626       {
55627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55628       };
55629     } catch (...) {
55630       {
55631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55632       };
55633     }
55634   }
55635
55636   jresult = (int)result;
55637   return jresult;
55638 }
55639
55640
55641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55642   int jresult ;
55643   int result;
55644
55645   {
55646     try {
55647       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55648     } catch (std::out_of_range& e) {
55649       {
55650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (std::exception& e) {
55653       {
55654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55655       };
55656     } catch (Dali::DaliException e) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55659       };
55660     } catch (...) {
55661       {
55662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55663       };
55664     }
55665   }
55666
55667   jresult = (int)result;
55668   return jresult;
55669 }
55670
55671
55672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55673   int jresult ;
55674   int result;
55675
55676   {
55677     try {
55678       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55679     } catch (std::out_of_range& e) {
55680       {
55681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (std::exception& e) {
55684       {
55685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (Dali::DaliException e) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55694       };
55695     }
55696   }
55697
55698   jresult = (int)result;
55699   return jresult;
55700 }
55701
55702
55703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55704   int jresult ;
55705   int result;
55706
55707   {
55708     try {
55709       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55710     } catch (std::out_of_range& e) {
55711       {
55712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55713       };
55714     } catch (std::exception& e) {
55715       {
55716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55717       };
55718     } catch (Dali::DaliException e) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55721       };
55722     } catch (...) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55725       };
55726     }
55727   }
55728
55729   jresult = (int)result;
55730   return jresult;
55731 }
55732
55733
55734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55735   int jresult ;
55736   int result;
55737
55738   {
55739     try {
55740       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (Dali::DaliException e) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55752       };
55753     } catch (...) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55756       };
55757     }
55758   }
55759
55760   jresult = (int)result;
55761   return jresult;
55762 }
55763
55764
55765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55766   int jresult ;
55767   int result;
55768
55769   {
55770     try {
55771       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55772     } catch (std::out_of_range& e) {
55773       {
55774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55775       };
55776     } catch (std::exception& e) {
55777       {
55778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55779       };
55780     } catch (Dali::DaliException e) {
55781       {
55782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55783       };
55784     } catch (...) {
55785       {
55786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55787       };
55788     }
55789   }
55790
55791   jresult = (int)result;
55792   return jresult;
55793 }
55794
55795
55796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55797   int jresult ;
55798   int result;
55799
55800   {
55801     try {
55802       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55803     } catch (std::out_of_range& e) {
55804       {
55805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55806       };
55807     } catch (std::exception& e) {
55808       {
55809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55810       };
55811     } catch (Dali::DaliException e) {
55812       {
55813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55814       };
55815     } catch (...) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55818       };
55819     }
55820   }
55821
55822   jresult = (int)result;
55823   return jresult;
55824 }
55825
55826
55827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55828   int jresult ;
55829   int result;
55830
55831   {
55832     try {
55833       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55841       };
55842     } catch (Dali::DaliException e) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55845       };
55846     } catch (...) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55849       };
55850     }
55851   }
55852
55853   jresult = (int)result;
55854   return jresult;
55855 }
55856
55857
55858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55859   int jresult ;
55860   int result;
55861
55862   {
55863     try {
55864       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55865     } catch (std::out_of_range& e) {
55866       {
55867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55868       };
55869     } catch (std::exception& e) {
55870       {
55871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55872       };
55873     } catch (Dali::DaliException e) {
55874       {
55875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55876       };
55877     } catch (...) {
55878       {
55879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55880       };
55881     }
55882   }
55883
55884   jresult = (int)result;
55885   return jresult;
55886 }
55887
55888
55889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55890   int jresult ;
55891   int result;
55892
55893   {
55894     try {
55895       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55896     } catch (std::out_of_range& e) {
55897       {
55898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55899       };
55900     } catch (std::exception& e) {
55901       {
55902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55903       };
55904     } catch (Dali::DaliException e) {
55905       {
55906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55907       };
55908     } catch (...) {
55909       {
55910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55911       };
55912     }
55913   }
55914
55915   jresult = (int)result;
55916   return jresult;
55917 }
55918
55919
55920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55921   int jresult ;
55922   int result;
55923
55924   {
55925     try {
55926       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55927     } catch (std::out_of_range& e) {
55928       {
55929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55930       };
55931     } catch (std::exception& e) {
55932       {
55933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55934       };
55935     } catch (Dali::DaliException e) {
55936       {
55937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55938       };
55939     } catch (...) {
55940       {
55941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55942       };
55943     }
55944   }
55945
55946   jresult = (int)result;
55947   return jresult;
55948 }
55949
55950
55951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55952   int jresult ;
55953   int result;
55954
55955   {
55956     try {
55957       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55958     } catch (std::out_of_range& e) {
55959       {
55960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55961       };
55962     } catch (std::exception& e) {
55963       {
55964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55965       };
55966     } catch (Dali::DaliException e) {
55967       {
55968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55969       };
55970     } catch (...) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55973       };
55974     }
55975   }
55976
55977   jresult = (int)result;
55978   return jresult;
55979 }
55980
55981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55982   int jresult ;
55983   int result;
55984
55985   {
55986     try {
55987       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55988     } catch (std::out_of_range& e) {
55989       {
55990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55991       };
55992     } catch (std::exception& e) {
55993       {
55994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55995       };
55996     } catch (Dali::DaliException e) {
55997       {
55998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55999       };
56000     } catch (...) {
56001       {
56002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56003       };
56004     }
56005   }
56006
56007   jresult = (int)result;
56008   return jresult;
56009 }
56010
56011
56012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56013   int jresult ;
56014   int result;
56015   {
56016     try
56017     {
56018       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56019     } catch (std::out_of_range& e) {
56020       {
56021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56022       };
56023     } catch (std::exception& e) {
56024       {
56025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (Dali::DaliException e) {
56028       {
56029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56030       };
56031     } catch (...) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56034       };
56035     }
56036   }
56037
56038   jresult = (int)result;
56039   return jresult;
56040 }
56041
56042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56043   int jresult ;
56044   int result;
56045   {
56046     try
56047     {
56048       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (Dali::DaliException e) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56060       };
56061     } catch (...) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56064       };
56065     }
56066   }
56067
56068   jresult = (int)result;
56069   return jresult;
56070 }
56071
56072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56073   int jresult ;
56074   int result;
56075   {
56076     try
56077     {
56078       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56079     } catch (std::out_of_range& e) {
56080       {
56081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (std::exception& e) {
56084       {
56085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (Dali::DaliException e) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56090       };
56091     } catch (...) {
56092       {
56093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56094       };
56095     }
56096   }
56097
56098   jresult = (int)result;
56099   return jresult;
56100 }
56101
56102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56103   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56104 }
56105
56106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56107   int jresult ;
56108   int result;
56109   {
56110     try
56111     {
56112       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56113     } catch (std::out_of_range& e) {
56114       {
56115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56116       };
56117     } catch (std::exception& e) {
56118       {
56119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56120       };
56121     } catch (Dali::DaliException e) {
56122       {
56123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56124       };
56125     } catch (...) {
56126       {
56127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56128       };
56129     }
56130   }
56131
56132   jresult = (int)result;
56133   return jresult;
56134 }
56135
56136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56137   int jresult ;
56138   int result;
56139   {
56140     try
56141     {
56142       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56143     } catch (std::out_of_range& e) {
56144       {
56145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (std::exception& e) {
56148       {
56149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (Dali::DaliException e) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56154       };
56155     } catch (...) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56158       };
56159     }
56160   }
56161
56162   jresult = (int)result;
56163   return jresult;
56164 }
56165
56166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56167   int jresult ;
56168   int result;
56169
56170   {
56171     try {
56172       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56188       };
56189     }
56190   }
56191
56192   jresult = (int)result;
56193   return jresult;
56194 }
56195
56196
56197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56198   int jresult ;
56199   int result;
56200
56201   {
56202     try {
56203       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56204     } catch (std::out_of_range& e) {
56205       {
56206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (std::exception& e) {
56209       {
56210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (Dali::DaliException e) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222
56223   jresult = (int)result;
56224   return jresult;
56225 }
56226
56227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56228   int jresult ;
56229   int result;
56230   {
56231     try
56232     {
56233       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248   jresult = (int)result;
56249   return jresult;
56250 }
56251
56252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56253   int jresult ;
56254   int result;
56255   {
56256     try
56257     {
56258       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56259     } catch (std::out_of_range& e) {
56260       {
56261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56262       };
56263     } catch (std::exception& e) {
56264       {
56265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56266       };
56267     } catch (...) {
56268       {
56269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56270       };
56271     }
56272   }
56273   jresult = (int)result;
56274   return jresult;
56275 }
56276
56277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56278   int jresult ;
56279   int result;
56280   {
56281     try
56282     {
56283       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56284     } catch (std::out_of_range& e) {
56285       {
56286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56287       };
56288     } catch (std::exception& e) {
56289       {
56290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56291       };
56292     } catch (...) {
56293       {
56294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56295       };
56296     }
56297   }
56298   jresult = (int)result;
56299   return jresult;
56300 }
56301
56302
56303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56304   int jresult ;
56305   int result;
56306   {
56307     try
56308     {
56309       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56310     } catch (std::out_of_range& e) {
56311       {
56312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56313       };
56314     } catch (std::exception& e) {
56315       {
56316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56317       };
56318     } catch (...) {
56319       {
56320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56321       };
56322     }
56323   }
56324   jresult = (int)result;
56325   return jresult;
56326 }
56327
56328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56329   int jresult ;
56330   int result;
56331   {
56332     try
56333     {
56334       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56346       };
56347     }
56348   }
56349   jresult = (int)result;
56350   return jresult;
56351 }
56352
56353
56354
56355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56356   int jresult ;
56357   int result;
56358
56359   {
56360     try {
56361       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (Dali::DaliException e) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56373       };
56374     } catch (...) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56377       };
56378     }
56379   }
56380
56381   jresult = (int)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56387   int jresult ;
56388   int result;
56389
56390   {
56391     try {
56392       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56400       };
56401     } catch (Dali::DaliException e) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56404       };
56405     } catch (...) {
56406       {
56407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56408       };
56409     }
56410   }
56411
56412   jresult = (int)result;
56413   return jresult;
56414 }
56415
56416
56417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56418   int jresult ;
56419   int result;
56420
56421   {
56422     try {
56423       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56424     } catch (std::out_of_range& e) {
56425       {
56426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (std::exception& e) {
56429       {
56430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (Dali::DaliException e) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56435       };
56436     } catch (...) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56439       };
56440     }
56441   }
56442
56443   jresult = (int)result;
56444   return jresult;
56445 }
56446
56447
56448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56449   int jresult ;
56450   int result;
56451
56452   {
56453     try {
56454       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (Dali::DaliException e) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56466       };
56467     } catch (...) {
56468       {
56469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56470       };
56471     }
56472   }
56473
56474   jresult = (int)result;
56475   return jresult;
56476 }
56477
56478
56479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56480   int jresult ;
56481   int result;
56482
56483   {
56484     try {
56485       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56486     } catch (std::out_of_range& e) {
56487       {
56488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56489       };
56490     } catch (std::exception& e) {
56491       {
56492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56493       };
56494     } catch (Dali::DaliException e) {
56495       {
56496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56501       };
56502     }
56503   }
56504
56505   jresult = (int)result;
56506   return jresult;
56507 }
56508
56509
56510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56511   int jresult ;
56512   int result;
56513
56514   {
56515     try {
56516       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56517     } catch (std::out_of_range& e) {
56518       {
56519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56520       };
56521     } catch (std::exception& e) {
56522       {
56523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (Dali::DaliException e) {
56526       {
56527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56532       };
56533     }
56534   }
56535
56536   jresult = (int)result;
56537   return jresult;
56538 }
56539
56540
56541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56542   int jresult ;
56543   int result;
56544
56545   {
56546     try {
56547       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56548     } catch (std::out_of_range& e) {
56549       {
56550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56551       };
56552     } catch (std::exception& e) {
56553       {
56554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56555       };
56556     } catch (Dali::DaliException e) {
56557       {
56558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56559       };
56560     } catch (...) {
56561       {
56562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56563       };
56564     }
56565   }
56566
56567   jresult = (int)result;
56568   return jresult;
56569 }
56570
56571 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56572   int jresult ;
56573   int result;
56574
56575   {
56576     try {
56577       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56578     } catch (std::out_of_range& e) {
56579       {
56580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56581       };
56582     } catch (std::exception& e) {
56583       {
56584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56585       };
56586     } catch (...) {
56587       {
56588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56589       };
56590     }
56591   }
56592   jresult = (int)result;
56593   return jresult;
56594 }
56595
56596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56597   int jresult ;
56598   int result;
56599
56600   {
56601     try {
56602       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56603     } catch (std::out_of_range& e) {
56604       {
56605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56606       };
56607     } catch (std::exception& e) {
56608       {
56609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56610       };
56611     } catch (Dali::DaliException e) {
56612       {
56613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56614       };
56615     } catch (...) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56618       };
56619     }
56620   }
56621
56622   jresult = (int)result;
56623   return jresult;
56624 }
56625
56626
56627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56628   int jresult ;
56629   int result;
56630
56631   {
56632     try {
56633       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56634     } catch (std::out_of_range& e) {
56635       {
56636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56637       };
56638     } catch (std::exception& e) {
56639       {
56640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56641       };
56642     } catch (Dali::DaliException e) {
56643       {
56644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56645       };
56646     } catch (...) {
56647       {
56648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56649       };
56650     }
56651   }
56652
56653   jresult = (int)result;
56654   return jresult;
56655 }
56656
56657
56658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56659   int jresult ;
56660   int result;
56661
56662   {
56663     try {
56664       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56665     } catch (std::out_of_range& e) {
56666       {
56667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56668       };
56669     } catch (std::exception& e) {
56670       {
56671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56672       };
56673     } catch (Dali::DaliException e) {
56674       {
56675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56676       };
56677     } catch (...) {
56678       {
56679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56680       };
56681     }
56682   }
56683
56684   jresult = (int)result;
56685   return jresult;
56686 }
56687
56688
56689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56690   int jresult ;
56691   int result;
56692
56693   {
56694     try {
56695       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56696     } catch (std::out_of_range& e) {
56697       {
56698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56699       };
56700     } catch (std::exception& e) {
56701       {
56702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56703       };
56704     } catch (Dali::DaliException e) {
56705       {
56706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56707       };
56708     } catch (...) {
56709       {
56710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56711       };
56712     }
56713   }
56714
56715   jresult = (int)result;
56716   return jresult;
56717 }
56718
56719
56720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56721   int jresult ;
56722   int result;
56723
56724   {
56725     try {
56726       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56727     } catch (std::out_of_range& e) {
56728       {
56729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56730       };
56731     } catch (std::exception& e) {
56732       {
56733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (Dali::DaliException e) {
56736       {
56737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56738       };
56739     } catch (...) {
56740       {
56741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56742       };
56743     }
56744   }
56745
56746   jresult = (int)result;
56747   return jresult;
56748 }
56749
56750
56751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56752   int jresult ;
56753   int result;
56754
56755   {
56756     try {
56757       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56758     } catch (std::out_of_range& e) {
56759       {
56760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56761       };
56762     } catch (std::exception& e) {
56763       {
56764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56765       };
56766     } catch (Dali::DaliException e) {
56767       {
56768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56769       };
56770     } catch (...) {
56771       {
56772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56773       };
56774     }
56775   }
56776
56777   jresult = (int)result;
56778   return jresult;
56779 }
56780
56781
56782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56783   int jresult ;
56784   int result;
56785
56786   {
56787     try {
56788       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56789     } catch (std::out_of_range& e) {
56790       {
56791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56792       };
56793     } catch (std::exception& e) {
56794       {
56795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56796       };
56797     } catch (Dali::DaliException e) {
56798       {
56799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56800       };
56801     } catch (...) {
56802       {
56803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56804       };
56805     }
56806   }
56807
56808   jresult = (int)result;
56809   return jresult;
56810 }
56811
56812
56813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56814   int jresult ;
56815   int result;
56816
56817   {
56818     try {
56819       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56820     } catch (std::out_of_range& e) {
56821       {
56822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56823       };
56824     } catch (std::exception& e) {
56825       {
56826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56827       };
56828     } catch (Dali::DaliException e) {
56829       {
56830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56831       };
56832     } catch (...) {
56833       {
56834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56835       };
56836     }
56837   }
56838
56839   jresult = (int)result;
56840   return jresult;
56841 }
56842
56843
56844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56845   int jresult ;
56846   int result;
56847
56848   {
56849     try {
56850       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56851     } catch (std::out_of_range& e) {
56852       {
56853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (std::exception& e) {
56856       {
56857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56858       };
56859     } catch (Dali::DaliException e) {
56860       {
56861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56862       };
56863     } catch (...) {
56864       {
56865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56866       };
56867     }
56868   }
56869
56870   jresult = (int)result;
56871   return jresult;
56872 }
56873
56874
56875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56876   int jresult ;
56877   int result;
56878
56879   {
56880     try {
56881       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56882     } catch (std::out_of_range& e) {
56883       {
56884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56885       };
56886     } catch (std::exception& e) {
56887       {
56888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56889       };
56890     } catch (Dali::DaliException e) {
56891       {
56892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56893       };
56894     } catch (...) {
56895       {
56896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56897       };
56898     }
56899   }
56900
56901   jresult = (int)result;
56902   return jresult;
56903 }
56904
56905
56906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56907   int jresult ;
56908   int result;
56909
56910   {
56911     try {
56912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56913     } catch (std::out_of_range& e) {
56914       {
56915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (std::exception& e) {
56918       {
56919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (Dali::DaliException e) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56924       };
56925     } catch (...) {
56926       {
56927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56928       };
56929     }
56930   }
56931
56932   jresult = (int)result;
56933   return jresult;
56934 }
56935
56936
56937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56938   int jresult ;
56939   int result;
56940
56941   {
56942     try {
56943       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56944     } catch (std::out_of_range& e) {
56945       {
56946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56947       };
56948     } catch (std::exception& e) {
56949       {
56950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56951       };
56952     } catch (Dali::DaliException e) {
56953       {
56954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56955       };
56956     } catch (...) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56959       };
56960     }
56961   }
56962
56963   jresult = (int)result;
56964   return jresult;
56965 }
56966
56967
56968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56969   int jresult ;
56970   int result;
56971
56972   {
56973     try {
56974       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56975     } catch (std::out_of_range& e) {
56976       {
56977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56978       };
56979     } catch (std::exception& e) {
56980       {
56981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (Dali::DaliException e) {
56984       {
56985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56986       };
56987     } catch (...) {
56988       {
56989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56990       };
56991     }
56992   }
56993
56994   jresult = (int)result;
56995   return jresult;
56996 }
56997
56998
56999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57000   int jresult ;
57001   int result;
57002
57003   {
57004     try {
57005       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57006     } catch (std::out_of_range& e) {
57007       {
57008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57009       };
57010     } catch (std::exception& e) {
57011       {
57012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57013       };
57014     } catch (Dali::DaliException e) {
57015       {
57016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57017       };
57018     } catch (...) {
57019       {
57020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57021       };
57022     }
57023   }
57024
57025   jresult = (int)result;
57026   return jresult;
57027 }
57028
57029
57030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57031   int jresult ;
57032   int result;
57033
57034   {
57035     try {
57036       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57037     } catch (std::out_of_range& e) {
57038       {
57039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57040       };
57041     } catch (std::exception& e) {
57042       {
57043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57044       };
57045     } catch (Dali::DaliException e) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57048       };
57049     } catch (...) {
57050       {
57051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57052       };
57053     }
57054   }
57055
57056   jresult = (int)result;
57057   return jresult;
57058 }
57059
57060
57061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57062   int jresult ;
57063   int result;
57064
57065   {
57066     try {
57067       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57068     } catch (std::out_of_range& e) {
57069       {
57070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57071       };
57072     } catch (std::exception& e) {
57073       {
57074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57075       };
57076     } catch (Dali::DaliException e) {
57077       {
57078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57079       };
57080     } catch (...) {
57081       {
57082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57083       };
57084     }
57085   }
57086
57087   jresult = (int)result;
57088   return jresult;
57089 }
57090
57091
57092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57093   int jresult ;
57094   int result;
57095
57096   {
57097     try {
57098       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57099     } catch (std::out_of_range& e) {
57100       {
57101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57102       };
57103     } catch (std::exception& e) {
57104       {
57105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57106       };
57107     } catch (Dali::DaliException e) {
57108       {
57109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57110       };
57111     } catch (...) {
57112       {
57113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57114       };
57115     }
57116   }
57117
57118   jresult = (int)result;
57119   return jresult;
57120 }
57121
57122
57123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57124   int jresult ;
57125   int result;
57126
57127   {
57128     try {
57129       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57130     } catch (std::out_of_range& e) {
57131       {
57132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57133       };
57134     } catch (std::exception& e) {
57135       {
57136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57137       };
57138     } catch (Dali::DaliException e) {
57139       {
57140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57141       };
57142     } catch (...) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57145       };
57146     }
57147   }
57148
57149   jresult = (int)result;
57150   return jresult;
57151 }
57152
57153
57154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57155   int jresult ;
57156   int result;
57157
57158   {
57159     try {
57160       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57161     } catch (std::out_of_range& e) {
57162       {
57163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (std::exception& e) {
57166       {
57167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57168       };
57169     } catch (Dali::DaliException e) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57172       };
57173     } catch (...) {
57174       {
57175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57176       };
57177     }
57178   }
57179
57180   jresult = (int)result;
57181   return jresult;
57182 }
57183
57184
57185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57186   int jresult ;
57187   int result;
57188
57189   {
57190     try {
57191       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57199       };
57200     } catch (Dali::DaliException e) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57203       };
57204     } catch (...) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57207       };
57208     }
57209   }
57210
57211   jresult = (int)result;
57212   return jresult;
57213 }
57214
57215
57216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57217   int jresult ;
57218   int result;
57219
57220   {
57221     try {
57222       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57223     } catch (std::out_of_range& e) {
57224       {
57225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (std::exception& e) {
57228       {
57229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (Dali::DaliException e) {
57232       {
57233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57234       };
57235     } catch (...) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57238       };
57239     }
57240   }
57241
57242   jresult = (int)result;
57243   return jresult;
57244 }
57245
57246
57247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57248   int jresult ;
57249   int result;
57250
57251   {
57252     try {
57253       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57254     } catch (std::out_of_range& e) {
57255       {
57256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57257       };
57258     } catch (std::exception& e) {
57259       {
57260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57261       };
57262     } catch (Dali::DaliException e) {
57263       {
57264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57265       };
57266     } catch (...) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57269       };
57270     }
57271   }
57272
57273   jresult = (int)result;
57274   return jresult;
57275 }
57276
57277
57278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57279   int jresult ;
57280   int result;
57281
57282   {
57283     try {
57284       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (Dali::DaliException e) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57300       };
57301     }
57302   }
57303
57304   jresult = (int)result;
57305   return jresult;
57306 }
57307
57308
57309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57310   int jresult ;
57311   int result;
57312
57313   {
57314     try {
57315       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57316     } catch (std::out_of_range& e) {
57317       {
57318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57319       };
57320     } catch (std::exception& e) {
57321       {
57322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57323       };
57324     } catch (Dali::DaliException e) {
57325       {
57326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57327       };
57328     } catch (...) {
57329       {
57330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57331       };
57332     }
57333   }
57334
57335   jresult = (int)result;
57336   return jresult;
57337 }
57338
57339
57340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57341   int jresult ;
57342   int result;
57343
57344   {
57345     try {
57346       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57347     } catch (std::out_of_range& e) {
57348       {
57349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57350       };
57351     } catch (std::exception& e) {
57352       {
57353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57354       };
57355     } catch (Dali::DaliException e) {
57356       {
57357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57358       };
57359     } catch (...) {
57360       {
57361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57362       };
57363     }
57364   }
57365
57366   jresult = (int)result;
57367   return jresult;
57368 }
57369
57370
57371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57372   int jresult ;
57373   int result;
57374
57375   {
57376     try {
57377       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57378     } catch (std::out_of_range& e) {
57379       {
57380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57381       };
57382     } catch (std::exception& e) {
57383       {
57384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (Dali::DaliException e) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57389       };
57390     } catch (...) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57393       };
57394     }
57395   }
57396
57397   jresult = (int)result;
57398   return jresult;
57399 }
57400
57401
57402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57403   int jresult ;
57404   int result;
57405
57406   {
57407     try {
57408       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57409     } catch (std::out_of_range& e) {
57410       {
57411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57412       };
57413     } catch (std::exception& e) {
57414       {
57415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57416       };
57417     } catch (Dali::DaliException e) {
57418       {
57419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57420       };
57421     } catch (...) {
57422       {
57423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57424       };
57425     }
57426   }
57427
57428   jresult = (int)result;
57429   return jresult;
57430 }
57431
57432
57433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57434   int jresult ;
57435   int result;
57436
57437   {
57438     try {
57439       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57440     } catch (std::out_of_range& e) {
57441       {
57442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57443       };
57444     } catch (std::exception& e) {
57445       {
57446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57447       };
57448     } catch (Dali::DaliException e) {
57449       {
57450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57451       };
57452     } catch (...) {
57453       {
57454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57455       };
57456     }
57457   }
57458
57459   jresult = (int)result;
57460   return jresult;
57461 }
57462
57463
57464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57465   void * jresult ;
57466   Dali::Toolkit::Builder *result = 0 ;
57467
57468   {
57469     try {
57470       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57471     } catch (std::out_of_range& e) {
57472       {
57473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57474       };
57475     } catch (std::exception& e) {
57476       {
57477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57478       };
57479     } catch (Dali::DaliException e) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57482       };
57483     } catch (...) {
57484       {
57485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57486       };
57487     }
57488   }
57489
57490   jresult = (void *)result;
57491   return jresult;
57492 }
57493
57494
57495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57496   void * jresult ;
57497   Dali::Toolkit::Builder result;
57498
57499   {
57500     try {
57501       result = Dali::Toolkit::Builder::New();
57502     } catch (std::out_of_range& e) {
57503       {
57504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57505       };
57506     } catch (std::exception& e) {
57507       {
57508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57509       };
57510     } catch (Dali::DaliException e) {
57511       {
57512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57513       };
57514     } catch (...) {
57515       {
57516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57517       };
57518     }
57519   }
57520
57521   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57522   return jresult;
57523 }
57524
57525
57526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57527   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57528
57529   arg1 = (Dali::Toolkit::Builder *)jarg1;
57530   {
57531     try {
57532       delete arg1;
57533     } catch (std::out_of_range& e) {
57534       {
57535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57536       };
57537     } catch (std::exception& e) {
57538       {
57539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57540       };
57541     } catch (Dali::DaliException e) {
57542       {
57543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57544       };
57545     } catch (...) {
57546       {
57547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57548       };
57549     }
57550   }
57551
57552 }
57553
57554
57555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57556   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57557   std::string *arg2 = 0 ;
57558   Dali::Toolkit::Builder::UIFormat arg3 ;
57559
57560   arg1 = (Dali::Toolkit::Builder *)jarg1;
57561   if (!jarg2) {
57562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57563     return ;
57564   }
57565   std::string arg2_str(jarg2);
57566   arg2 = &arg2_str;
57567   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57568   {
57569     try {
57570       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57571     } catch (std::out_of_range& e) {
57572       {
57573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57574       };
57575     } catch (std::exception& e) {
57576       {
57577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57578       };
57579     } catch (Dali::DaliException e) {
57580       {
57581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57582       };
57583     } catch (...) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57586       };
57587     }
57588   }
57589
57590
57591   //argout typemap for const std::string&
57592
57593 }
57594
57595
57596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57597   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57598   std::string *arg2 = 0 ;
57599
57600   arg1 = (Dali::Toolkit::Builder *)jarg1;
57601   if (!jarg2) {
57602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57603     return ;
57604   }
57605   std::string arg2_str(jarg2);
57606   arg2 = &arg2_str;
57607   {
57608     try {
57609       (arg1)->LoadFromString((std::string const &)*arg2);
57610     } catch (std::out_of_range& e) {
57611       {
57612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57613       };
57614     } catch (std::exception& e) {
57615       {
57616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57617       };
57618     } catch (Dali::DaliException e) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57621       };
57622     } catch (...) {
57623       {
57624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57625       };
57626     }
57627   }
57628
57629
57630   //argout typemap for const std::string&
57631
57632 }
57633
57634
57635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57637   Dali::Property::Map *arg2 = 0 ;
57638
57639   arg1 = (Dali::Toolkit::Builder *)jarg1;
57640   arg2 = (Dali::Property::Map *)jarg2;
57641   if (!arg2) {
57642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57643     return ;
57644   }
57645   {
57646     try {
57647       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57648     } catch (std::out_of_range& e) {
57649       {
57650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57651       };
57652     } catch (std::exception& e) {
57653       {
57654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57655       };
57656     } catch (Dali::DaliException e) {
57657       {
57658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57659       };
57660     } catch (...) {
57661       {
57662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57663       };
57664     }
57665   }
57666
57667 }
57668
57669
57670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57671   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57672   std::string *arg2 = 0 ;
57673   Dali::Property::Value *arg3 = 0 ;
57674
57675   arg1 = (Dali::Toolkit::Builder *)jarg1;
57676   if (!jarg2) {
57677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57678     return ;
57679   }
57680   std::string arg2_str(jarg2);
57681   arg2 = &arg2_str;
57682   arg3 = (Dali::Property::Value *)jarg3;
57683   if (!arg3) {
57684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57685     return ;
57686   }
57687   {
57688     try {
57689       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57690     } catch (std::out_of_range& e) {
57691       {
57692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57693       };
57694     } catch (std::exception& e) {
57695       {
57696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57697       };
57698     } catch (Dali::DaliException e) {
57699       {
57700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57701       };
57702     } catch (...) {
57703       {
57704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57705       };
57706     }
57707   }
57708
57709
57710   //argout typemap for const std::string&
57711
57712 }
57713
57714
57715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57716   void * jresult ;
57717   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57718   Dali::Property::Map *result = 0 ;
57719
57720   arg1 = (Dali::Toolkit::Builder *)jarg1;
57721   {
57722     try {
57723       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57724     } catch (std::out_of_range& e) {
57725       {
57726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57727       };
57728     } catch (std::exception& e) {
57729       {
57730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57731       };
57732     } catch (Dali::DaliException e) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57739       };
57740     }
57741   }
57742
57743   jresult = (void *)result;
57744   return jresult;
57745 }
57746
57747
57748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57749   void * jresult ;
57750   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57751   std::string *arg2 = 0 ;
57752   Dali::Property::Value *result = 0 ;
57753
57754   arg1 = (Dali::Toolkit::Builder *)jarg1;
57755   if (!jarg2) {
57756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57757     return 0;
57758   }
57759   std::string arg2_str(jarg2);
57760   arg2 = &arg2_str;
57761   {
57762     try {
57763       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57764     } catch (std::out_of_range& e) {
57765       {
57766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57767       };
57768     } catch (std::exception& e) {
57769       {
57770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57771       };
57772     } catch (Dali::DaliException e) {
57773       {
57774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57775       };
57776     } catch (...) {
57777       {
57778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57779       };
57780     }
57781   }
57782
57783   jresult = (void *)result;
57784
57785   //argout typemap for const std::string&
57786
57787   return jresult;
57788 }
57789
57790
57791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57792   void * jresult ;
57793   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57794   std::string *arg2 = 0 ;
57795   Dali::Animation result;
57796
57797   arg1 = (Dali::Toolkit::Builder *)jarg1;
57798   if (!jarg2) {
57799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57800     return 0;
57801   }
57802   std::string arg2_str(jarg2);
57803   arg2 = &arg2_str;
57804   {
57805     try {
57806       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57807     } catch (std::out_of_range& e) {
57808       {
57809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57810       };
57811     } catch (std::exception& e) {
57812       {
57813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57814       };
57815     } catch (Dali::DaliException e) {
57816       {
57817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57818       };
57819     } catch (...) {
57820       {
57821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57822       };
57823     }
57824   }
57825
57826   jresult = new Dali::Animation((const Dali::Animation &)result);
57827
57828   //argout typemap for const std::string&
57829
57830   return jresult;
57831 }
57832
57833
57834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57835   void * jresult ;
57836   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57837   std::string *arg2 = 0 ;
57838   Dali::Property::Map *arg3 = 0 ;
57839   Dali::Animation result;
57840
57841   arg1 = (Dali::Toolkit::Builder *)jarg1;
57842   if (!jarg2) {
57843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57844     return 0;
57845   }
57846   std::string arg2_str(jarg2);
57847   arg2 = &arg2_str;
57848   arg3 = (Dali::Property::Map *)jarg3;
57849   if (!arg3) {
57850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57851     return 0;
57852   }
57853   {
57854     try {
57855       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57856     } catch (std::out_of_range& e) {
57857       {
57858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57859       };
57860     } catch (std::exception& e) {
57861       {
57862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57863       };
57864     } catch (Dali::DaliException e) {
57865       {
57866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57867       };
57868     } catch (...) {
57869       {
57870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57871       };
57872     }
57873   }
57874
57875   jresult = new Dali::Animation((const Dali::Animation &)result);
57876
57877   //argout typemap for const std::string&
57878
57879   return jresult;
57880 }
57881
57882
57883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57884   void * jresult ;
57885   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57886   std::string *arg2 = 0 ;
57887   Dali::Actor arg3 ;
57888   Dali::Actor *argp3 ;
57889   Dali::Animation result;
57890
57891   arg1 = (Dali::Toolkit::Builder *)jarg1;
57892   if (!jarg2) {
57893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57894     return 0;
57895   }
57896   std::string arg2_str(jarg2);
57897   arg2 = &arg2_str;
57898   argp3 = (Dali::Actor *)jarg3;
57899   if (!argp3) {
57900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57901     return 0;
57902   }
57903   arg3 = *argp3;
57904   {
57905     try {
57906       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57907     } catch (std::out_of_range& e) {
57908       {
57909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57910       };
57911     } catch (std::exception& e) {
57912       {
57913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57914       };
57915     } catch (Dali::DaliException e) {
57916       {
57917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57918       };
57919     } catch (...) {
57920       {
57921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57922       };
57923     }
57924   }
57925
57926   jresult = new Dali::Animation((const Dali::Animation &)result);
57927
57928   //argout typemap for const std::string&
57929
57930   return jresult;
57931 }
57932
57933
57934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57935   void * jresult ;
57936   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57937   std::string *arg2 = 0 ;
57938   Dali::Property::Map *arg3 = 0 ;
57939   Dali::Actor arg4 ;
57940   Dali::Actor *argp4 ;
57941   Dali::Animation result;
57942
57943   arg1 = (Dali::Toolkit::Builder *)jarg1;
57944   if (!jarg2) {
57945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57946     return 0;
57947   }
57948   std::string arg2_str(jarg2);
57949   arg2 = &arg2_str;
57950   arg3 = (Dali::Property::Map *)jarg3;
57951   if (!arg3) {
57952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57953     return 0;
57954   }
57955   argp4 = (Dali::Actor *)jarg4;
57956   if (!argp4) {
57957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57958     return 0;
57959   }
57960   arg4 = *argp4;
57961   {
57962     try {
57963       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57964     } catch (std::out_of_range& e) {
57965       {
57966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57967       };
57968     } catch (std::exception& e) {
57969       {
57970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57971       };
57972     } catch (Dali::DaliException e) {
57973       {
57974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57975       };
57976     } catch (...) {
57977       {
57978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57979       };
57980     }
57981   }
57982
57983   jresult = new Dali::Animation((const Dali::Animation &)result);
57984
57985   //argout typemap for const std::string&
57986
57987   return jresult;
57988 }
57989
57990
57991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57992   void * jresult ;
57993   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57994   std::string *arg2 = 0 ;
57995   Dali::BaseHandle result;
57996
57997   arg1 = (Dali::Toolkit::Builder *)jarg1;
57998   if (!jarg2) {
57999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58000     return 0;
58001   }
58002   std::string arg2_str(jarg2);
58003   arg2 = &arg2_str;
58004   {
58005     try {
58006       result = (arg1)->Create((std::string const &)*arg2);
58007     } catch (std::out_of_range& e) {
58008       {
58009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58010       };
58011     } catch (std::exception& e) {
58012       {
58013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58014       };
58015     } catch (Dali::DaliException e) {
58016       {
58017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58018       };
58019     } catch (...) {
58020       {
58021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58022       };
58023     }
58024   }
58025
58026   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58027
58028   //argout typemap for const std::string&
58029
58030   return jresult;
58031 }
58032
58033
58034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58035   void * jresult ;
58036   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58037   std::string *arg2 = 0 ;
58038   Dali::Property::Map *arg3 = 0 ;
58039   Dali::BaseHandle result;
58040
58041   arg1 = (Dali::Toolkit::Builder *)jarg1;
58042   if (!jarg2) {
58043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58044     return 0;
58045   }
58046   std::string arg2_str(jarg2);
58047   arg2 = &arg2_str;
58048   arg3 = (Dali::Property::Map *)jarg3;
58049   if (!arg3) {
58050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58051     return 0;
58052   }
58053   {
58054     try {
58055       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58056     } catch (std::out_of_range& e) {
58057       {
58058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58059       };
58060     } catch (std::exception& e) {
58061       {
58062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58063       };
58064     } catch (Dali::DaliException e) {
58065       {
58066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58067       };
58068     } catch (...) {
58069       {
58070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58071       };
58072     }
58073   }
58074
58075   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58076
58077   //argout typemap for const std::string&
58078
58079   return jresult;
58080 }
58081
58082
58083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58084   void * jresult ;
58085   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58086   std::string *arg2 = 0 ;
58087   Dali::BaseHandle result;
58088
58089   arg1 = (Dali::Toolkit::Builder *)jarg1;
58090   if (!jarg2) {
58091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58092     return 0;
58093   }
58094   std::string arg2_str(jarg2);
58095   arg2 = &arg2_str;
58096   {
58097     try {
58098       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58099     } catch (std::out_of_range& e) {
58100       {
58101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58102       };
58103     } catch (std::exception& e) {
58104       {
58105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58106       };
58107     } catch (Dali::DaliException e) {
58108       {
58109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58110       };
58111     } catch (...) {
58112       {
58113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58114       };
58115     }
58116   }
58117
58118   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58119
58120   //argout typemap for const std::string&
58121
58122   return jresult;
58123 }
58124
58125
58126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58127   unsigned int jresult ;
58128   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58129   std::string *arg2 = 0 ;
58130   Dali::Handle *arg3 = 0 ;
58131   bool result;
58132
58133   arg1 = (Dali::Toolkit::Builder *)jarg1;
58134   if (!jarg2) {
58135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58136     return 0;
58137   }
58138   std::string arg2_str(jarg2);
58139   arg2 = &arg2_str;
58140   arg3 = (Dali::Handle *)jarg3;
58141   if (!arg3) {
58142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58143     return 0;
58144   }
58145   {
58146     try {
58147       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58148     } catch (std::out_of_range& e) {
58149       {
58150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (std::exception& e) {
58153       {
58154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58155       };
58156     } catch (Dali::DaliException e) {
58157       {
58158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58159       };
58160     } catch (...) {
58161       {
58162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58163       };
58164     }
58165   }
58166
58167   jresult = result;
58168
58169   //argout typemap for const std::string&
58170
58171   return jresult;
58172 }
58173
58174
58175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58176   unsigned int jresult ;
58177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58178   Dali::Handle *arg2 = 0 ;
58179   std::string *arg3 = 0 ;
58180   bool result;
58181
58182   arg1 = (Dali::Toolkit::Builder *)jarg1;
58183   arg2 = (Dali::Handle *)jarg2;
58184   if (!arg2) {
58185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58186     return 0;
58187   }
58188   if (!jarg3) {
58189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58190     return 0;
58191   }
58192   std::string arg3_str(jarg3);
58193   arg3 = &arg3_str;
58194   {
58195     try {
58196       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58197     } catch (std::out_of_range& e) {
58198       {
58199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58200       };
58201     } catch (std::exception& e) {
58202       {
58203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58204       };
58205     } catch (Dali::DaliException e) {
58206       {
58207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58208       };
58209     } catch (...) {
58210       {
58211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58212       };
58213     }
58214   }
58215
58216   jresult = result;
58217
58218   //argout typemap for const std::string&
58219
58220   return jresult;
58221 }
58222
58223
58224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58225   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58226   Dali::Actor arg2 ;
58227   Dali::Actor *argp2 ;
58228
58229   arg1 = (Dali::Toolkit::Builder *)jarg1;
58230   argp2 = (Dali::Actor *)jarg2;
58231   if (!argp2) {
58232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58233     return ;
58234   }
58235   arg2 = *argp2;
58236   {
58237     try {
58238       (arg1)->AddActors(arg2);
58239     } catch (std::out_of_range& e) {
58240       {
58241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58242       };
58243     } catch (std::exception& e) {
58244       {
58245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58246       };
58247     } catch (Dali::DaliException e) {
58248       {
58249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58250       };
58251     } catch (...) {
58252       {
58253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58254       };
58255     }
58256   }
58257
58258 }
58259
58260
58261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58262   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58263   std::string *arg2 = 0 ;
58264   Dali::Actor arg3 ;
58265   Dali::Actor *argp3 ;
58266
58267   arg1 = (Dali::Toolkit::Builder *)jarg1;
58268   if (!jarg2) {
58269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58270     return ;
58271   }
58272   std::string arg2_str(jarg2);
58273   arg2 = &arg2_str;
58274   argp3 = (Dali::Actor *)jarg3;
58275   if (!argp3) {
58276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58277     return ;
58278   }
58279   arg3 = *argp3;
58280   {
58281     try {
58282       (arg1)->AddActors((std::string const &)*arg2,arg3);
58283     } catch (std::out_of_range& e) {
58284       {
58285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58286       };
58287     } catch (std::exception& e) {
58288       {
58289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58290       };
58291     } catch (Dali::DaliException e) {
58292       {
58293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58294       };
58295     } catch (...) {
58296       {
58297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58298       };
58299     }
58300   }
58301
58302
58303   //argout typemap for const std::string&
58304
58305 }
58306
58307
58308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58309   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58310   std::string *arg2 = 0 ;
58311
58312   arg1 = (Dali::Toolkit::Builder *)jarg1;
58313   if (!jarg2) {
58314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58315     return ;
58316   }
58317   std::string arg2_str(jarg2);
58318   arg2 = &arg2_str;
58319   {
58320     try {
58321       (arg1)->CreateRenderTask((std::string const &)*arg2);
58322     } catch (std::out_of_range& e) {
58323       {
58324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (std::exception& e) {
58327       {
58328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (Dali::DaliException e) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58337       };
58338     }
58339   }
58340
58341
58342   //argout typemap for const std::string&
58343
58344 }
58345
58346
58347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58348   void * jresult ;
58349   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58350   std::string *arg2 = 0 ;
58351   Dali::Path result;
58352
58353   arg1 = (Dali::Toolkit::Builder *)jarg1;
58354   if (!jarg2) {
58355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58356     return 0;
58357   }
58358   std::string arg2_str(jarg2);
58359   arg2 = &arg2_str;
58360   {
58361     try {
58362       result = (arg1)->GetPath((std::string const &)*arg2);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58378       };
58379     }
58380   }
58381
58382   jresult = new Dali::Path((const Dali::Path &)result);
58383
58384   //argout typemap for const std::string&
58385
58386   return jresult;
58387 }
58388
58389
58390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58391   void * jresult ;
58392   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58393   std::string *arg2 = 0 ;
58394   Dali::PathConstrainer result;
58395
58396   arg1 = (Dali::Toolkit::Builder *)jarg1;
58397   if (!jarg2) {
58398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58399     return 0;
58400   }
58401   std::string arg2_str(jarg2);
58402   arg2 = &arg2_str;
58403   {
58404     try {
58405       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58406     } catch (std::out_of_range& e) {
58407       {
58408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58409       };
58410     } catch (std::exception& e) {
58411       {
58412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58413       };
58414     } catch (Dali::DaliException e) {
58415       {
58416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58417       };
58418     } catch (...) {
58419       {
58420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58421       };
58422     }
58423   }
58424
58425   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58426
58427   //argout typemap for const std::string&
58428
58429   return jresult;
58430 }
58431
58432
58433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58434   void * jresult ;
58435   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58436   std::string *arg2 = 0 ;
58437   Dali::LinearConstrainer result;
58438
58439   arg1 = (Dali::Toolkit::Builder *)jarg1;
58440   if (!jarg2) {
58441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58442     return 0;
58443   }
58444   std::string arg2_str(jarg2);
58445   arg2 = &arg2_str;
58446   {
58447     try {
58448       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58449     } catch (std::out_of_range& e) {
58450       {
58451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58452       };
58453     } catch (std::exception& e) {
58454       {
58455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58456       };
58457     } catch (Dali::DaliException e) {
58458       {
58459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58460       };
58461     } catch (...) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58464       };
58465     }
58466   }
58467
58468   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58469
58470   //argout typemap for const std::string&
58471
58472   return jresult;
58473 }
58474
58475
58476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58477   void * jresult ;
58478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58479   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58480
58481   arg1 = (Dali::Toolkit::Builder *)jarg1;
58482   {
58483     try {
58484       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58485     } catch (std::out_of_range& e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (std::exception& e) {
58490       {
58491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58492       };
58493     } catch (Dali::DaliException e) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58500       };
58501     }
58502   }
58503
58504   jresult = (void *)result;
58505   return jresult;
58506 }
58507
58508
58509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58510   void * jresult ;
58511   Dali::Toolkit::TransitionData *result = 0 ;
58512
58513   {
58514     try {
58515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (Dali::DaliException e) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58540   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58541
58542   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58543   {
58544     try {
58545       delete arg1;
58546     } catch (std::out_of_range& e) {
58547       {
58548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58549       };
58550     } catch (std::exception& e) {
58551       {
58552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58553       };
58554     } catch (Dali::DaliException e) {
58555       {
58556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58557       };
58558     } catch (...) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58561       };
58562     }
58563   }
58564
58565 }
58566
58567
58568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58569   void * jresult ;
58570   Dali::Property::Map *arg1 = 0 ;
58571   Dali::Toolkit::TransitionData result;
58572
58573   arg1 = (Dali::Property::Map *)jarg1;
58574   if (!arg1) {
58575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58576     return 0;
58577   }
58578   {
58579     try {
58580       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58581     } catch (std::out_of_range& e) {
58582       {
58583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58584       };
58585     } catch (std::exception& e) {
58586       {
58587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (Dali::DaliException e) {
58590       {
58591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58592       };
58593     } catch (...) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58596       };
58597     }
58598   }
58599
58600   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58601   return jresult;
58602 }
58603
58604
58605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58606   void * jresult ;
58607   Dali::Property::Array *arg1 = 0 ;
58608   Dali::Toolkit::TransitionData result;
58609
58610   arg1 = (Dali::Property::Array *)jarg1;
58611   if (!arg1) {
58612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58613     return 0;
58614   }
58615   {
58616     try {
58617       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
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::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58638   return jresult;
58639 }
58640
58641
58642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58643   void * jresult ;
58644   Dali::BaseHandle arg1 ;
58645   Dali::BaseHandle *argp1 ;
58646   Dali::Toolkit::TransitionData result;
58647
58648   argp1 = (Dali::BaseHandle *)jarg1;
58649   if (!argp1) {
58650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58651     return 0;
58652   }
58653   arg1 = *argp1;
58654   {
58655     try {
58656       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (Dali::DaliException e) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58668       };
58669     } catch (...) {
58670       {
58671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58672       };
58673     }
58674   }
58675
58676   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58677   return jresult;
58678 }
58679
58680
58681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58682   void * jresult ;
58683   Dali::Toolkit::TransitionData *arg1 = 0 ;
58684   Dali::Toolkit::TransitionData *result = 0 ;
58685
58686   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58687   if (!arg1) {
58688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58689     return 0;
58690   }
58691   {
58692     try {
58693       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58694     } catch (std::out_of_range& e) {
58695       {
58696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58697       };
58698     } catch (std::exception& e) {
58699       {
58700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58701       };
58702     } catch (Dali::DaliException e) {
58703       {
58704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58705       };
58706     } catch (...) {
58707       {
58708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58709       };
58710     }
58711   }
58712
58713   jresult = (void *)result;
58714   return jresult;
58715 }
58716
58717
58718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58719   void * jresult ;
58720   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58721   Dali::Toolkit::TransitionData *arg2 = 0 ;
58722   Dali::Toolkit::TransitionData *result = 0 ;
58723
58724   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58725   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58726   if (!arg2) {
58727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58728     return 0;
58729   }
58730   {
58731     try {
58732       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58733     } catch (std::out_of_range& e) {
58734       {
58735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58736       };
58737     } catch (std::exception& e) {
58738       {
58739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58740       };
58741     } catch (Dali::DaliException e) {
58742       {
58743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58744       };
58745     } catch (...) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58748       };
58749     }
58750   }
58751
58752   jresult = (void *)result;
58753   return jresult;
58754 }
58755
58756
58757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58758   unsigned long jresult ;
58759   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58760   size_t result;
58761
58762   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58763   {
58764     try {
58765       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58766     } catch (std::out_of_range& e) {
58767       {
58768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58769       };
58770     } catch (std::exception& e) {
58771       {
58772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58773       };
58774     } catch (Dali::DaliException e) {
58775       {
58776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58777       };
58778     } catch (...) {
58779       {
58780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58781       };
58782     }
58783   }
58784
58785   jresult = (unsigned long)result;
58786   return jresult;
58787 }
58788
58789
58790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58791   void * jresult ;
58792   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58793   size_t arg2 ;
58794   Dali::Property::Map result;
58795
58796   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58797   arg2 = (size_t)jarg2;
58798   {
58799     try {
58800       result = (arg1)->GetAnimatorAt(arg2);
58801     } catch (std::out_of_range& e) {
58802       {
58803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58804       };
58805     } catch (std::exception& e) {
58806       {
58807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58808       };
58809     } catch (Dali::DaliException e) {
58810       {
58811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58812       };
58813     } catch (...) {
58814       {
58815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58816       };
58817     }
58818   }
58819
58820   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58821   return jresult;
58822 }
58823
58824
58825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58826   int jresult ;
58827   int result;
58828
58829   {
58830     try {
58831       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58832     } catch (std::out_of_range& e) {
58833       {
58834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58835       };
58836     } catch (std::exception& e) {
58837       {
58838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58839       };
58840     } catch (Dali::DaliException e) {
58841       {
58842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58843       };
58844     } catch (...) {
58845       {
58846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58847       };
58848     }
58849   }
58850
58851   jresult = (int)result;
58852   return jresult;
58853 }
58854
58855
58856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58857   int jresult ;
58858   int result;
58859
58860   {
58861     try {
58862       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58863     } catch (std::out_of_range& e) {
58864       {
58865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58866       };
58867     } catch (std::exception& e) {
58868       {
58869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58870       };
58871     } catch (Dali::DaliException e) {
58872       {
58873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58874       };
58875     } catch (...) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58878       };
58879     }
58880   }
58881
58882   jresult = (int)result;
58883   return jresult;
58884 }
58885
58886
58887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58888   int jresult ;
58889   int result;
58890
58891   {
58892     try {
58893       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58894     } catch (std::out_of_range& e) {
58895       {
58896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58897       };
58898     } catch (std::exception& e) {
58899       {
58900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58901       };
58902     } catch (Dali::DaliException e) {
58903       {
58904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58905       };
58906     } catch (...) {
58907       {
58908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58909       };
58910     }
58911   }
58912
58913   jresult = (int)result;
58914   return jresult;
58915 }
58916
58917
58918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58919   int jresult ;
58920   int result;
58921
58922   {
58923     try {
58924       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58925     } catch (std::out_of_range& e) {
58926       {
58927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (std::exception& e) {
58930       {
58931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58932       };
58933     } catch (Dali::DaliException e) {
58934       {
58935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58936       };
58937     } catch (...) {
58938       {
58939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58940       };
58941     }
58942   }
58943
58944   jresult = (int)result;
58945   return jresult;
58946 }
58947
58948
58949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58950   int jresult ;
58951   int result;
58952
58953   {
58954     try {
58955       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58956     } catch (std::out_of_range& e) {
58957       {
58958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58959       };
58960     } catch (std::exception& e) {
58961       {
58962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58963       };
58964     } catch (Dali::DaliException e) {
58965       {
58966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58967       };
58968     } catch (...) {
58969       {
58970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58971       };
58972     }
58973   }
58974
58975   jresult = (int)result;
58976   return jresult;
58977 }
58978
58979
58980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58981   int jresult ;
58982   int result;
58983
58984   {
58985     try {
58986       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58987     } catch (std::out_of_range& e) {
58988       {
58989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (std::exception& e) {
58992       {
58993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58994       };
58995     } catch (Dali::DaliException e) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58998       };
58999     } catch (...) {
59000       {
59001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59002       };
59003     }
59004   }
59005
59006   jresult = (int)result;
59007   return jresult;
59008 }
59009
59010
59011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59012   int jresult ;
59013   int result;
59014
59015   {
59016     try {
59017       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59018     } catch (std::out_of_range& e) {
59019       {
59020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (std::exception& e) {
59023       {
59024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59025       };
59026     } catch (Dali::DaliException e) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59029       };
59030     } catch (...) {
59031       {
59032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59033       };
59034     }
59035   }
59036
59037   jresult = (int)result;
59038   return jresult;
59039 }
59040
59041
59042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59043   int jresult ;
59044   int result;
59045
59046   {
59047     try {
59048       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59049     } catch (std::out_of_range& e) {
59050       {
59051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (std::exception& e) {
59054       {
59055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59056       };
59057     } catch (Dali::DaliException e) {
59058       {
59059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59060       };
59061     } catch (...) {
59062       {
59063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59064       };
59065     }
59066   }
59067
59068   jresult = (int)result;
59069   return jresult;
59070 }
59071
59072
59073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59074   int jresult ;
59075   int result;
59076
59077   {
59078     try {
59079       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59080     } catch (std::out_of_range& e) {
59081       {
59082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59083       };
59084     } catch (std::exception& e) {
59085       {
59086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59087       };
59088     } catch (Dali::DaliException e) {
59089       {
59090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59091       };
59092     } catch (...) {
59093       {
59094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59095       };
59096     }
59097   }
59098
59099   jresult = (int)result;
59100   return jresult;
59101 }
59102
59103
59104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59105   int jresult ;
59106   int result;
59107
59108   {
59109     try {
59110       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59111     } catch (std::out_of_range& e) {
59112       {
59113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59114       };
59115     } catch (std::exception& e) {
59116       {
59117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59118       };
59119     } catch (Dali::DaliException e) {
59120       {
59121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59122       };
59123     } catch (...) {
59124       {
59125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59126       };
59127     }
59128   }
59129
59130   jresult = (int)result;
59131   return jresult;
59132 }
59133
59134
59135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59136   int jresult ;
59137   int result;
59138
59139   {
59140     try {
59141       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59142     } catch (std::out_of_range& e) {
59143       {
59144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59145       };
59146     } catch (std::exception& e) {
59147       {
59148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59149       };
59150     } catch (Dali::DaliException e) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59153       };
59154     } catch (...) {
59155       {
59156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59157       };
59158     }
59159   }
59160
59161   jresult = (int)result;
59162   return jresult;
59163 }
59164
59165
59166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59167   int jresult ;
59168   int result;
59169
59170   {
59171     try {
59172       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59173     } catch (std::out_of_range& e) {
59174       {
59175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (std::exception& e) {
59178       {
59179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (Dali::DaliException e) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59184       };
59185     } catch (...) {
59186       {
59187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59188       };
59189     }
59190   }
59191
59192   jresult = (int)result;
59193   return jresult;
59194 }
59195
59196
59197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59198   int jresult ;
59199   int result;
59200
59201   {
59202     try {
59203       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59204     } catch (std::out_of_range& e) {
59205       {
59206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59207       };
59208     } catch (std::exception& e) {
59209       {
59210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59211       };
59212     } catch (Dali::DaliException e) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59215       };
59216     } catch (...) {
59217       {
59218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59219       };
59220     }
59221   }
59222
59223   jresult = (int)result;
59224   return jresult;
59225 }
59226
59227
59228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59229   int jresult ;
59230   int result;
59231
59232   {
59233     try {
59234       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59235     } catch (std::out_of_range& e) {
59236       {
59237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (std::exception& e) {
59240       {
59241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (Dali::DaliException e) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59246       };
59247     } catch (...) {
59248       {
59249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59250       };
59251     }
59252   }
59253
59254   jresult = (int)result;
59255   return jresult;
59256 }
59257
59258
59259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59260   void * jresult ;
59261   Dali::Toolkit::Control result;
59262
59263   {
59264     try {
59265       result = Dali::Toolkit::Internal::Control::New();
59266     } catch (std::out_of_range& e) {
59267       {
59268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (std::exception& e) {
59271       {
59272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59273       };
59274     } catch (Dali::DaliException e) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59277       };
59278     } catch (...) {
59279       {
59280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59281       };
59282     }
59283   }
59284
59285   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59286   return jresult;
59287 }
59288
59289
59290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59292   std::string *arg2 = 0 ;
59293
59294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59295   if (!jarg2) {
59296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59297     return ;
59298   }
59299   std::string arg2_str(jarg2);
59300   arg2 = &arg2_str;
59301   {
59302     try {
59303       (arg1)->SetStyleName((std::string const &)*arg2);
59304     } catch (std::out_of_range& e) {
59305       {
59306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59307       };
59308     } catch (std::exception& e) {
59309       {
59310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59311       };
59312     } catch (Dali::DaliException e) {
59313       {
59314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59315       };
59316     } catch (...) {
59317       {
59318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59319       };
59320     }
59321   }
59322
59323
59324   //argout typemap for const std::string&
59325
59326 }
59327
59328
59329 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59330   char * jresult ;
59331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59332   std::string *result = 0 ;
59333
59334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59335   {
59336     try {
59337       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59338     } catch (std::out_of_range& e) {
59339       {
59340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59341       };
59342     } catch (std::exception& e) {
59343       {
59344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59345       };
59346     } catch (Dali::DaliException e) {
59347       {
59348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59349       };
59350     } catch (...) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59353       };
59354     }
59355   }
59356
59357   jresult = SWIG_csharp_string_callback(result->c_str());
59358   return jresult;
59359 }
59360
59361
59362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59364   Dali::Vector4 *arg2 = 0 ;
59365
59366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59367   arg2 = (Dali::Vector4 *)jarg2;
59368   if (!arg2) {
59369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59370     return ;
59371   }
59372   {
59373     try {
59374       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59375     } catch (std::out_of_range& e) {
59376       {
59377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59378       };
59379     } catch (std::exception& e) {
59380       {
59381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59382       };
59383     } catch (Dali::DaliException e) {
59384       {
59385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59386       };
59387     } catch (...) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59390       };
59391     }
59392   }
59393
59394 }
59395
59396
59397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59398   void * jresult ;
59399   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59400   Dali::Vector4 result;
59401
59402   arg1 = (Dali::Handle *)jarg1;
59403   {
59404     try {
59405       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59406       if (resultMap)
59407       {
59408         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59409         if(type && type->Get<int>() == Visual::COLOR )
59410         {
59411           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59412           if (value)
59413           {
59414             result = value->Get<Vector4>();
59415           }
59416         }
59417       }
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (Dali::DaliException e) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59429       };
59430     } catch (...) {
59431       {
59432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59433       };
59434     }
59435   }
59436
59437   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59438   return jresult;
59439 }
59440
59441
59442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59444   Dali::Property::Map *arg2 = 0 ;
59445
59446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59447   arg2 = (Dali::Property::Map *)jarg2;
59448   if (!arg2) {
59449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59450     return ;
59451   }
59452   {
59453     try {
59454       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59455     } catch (std::out_of_range& e) {
59456       {
59457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59458       };
59459     } catch (std::exception& e) {
59460       {
59461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59462       };
59463     } catch (Dali::DaliException e) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59466       };
59467     } catch (...) {
59468       {
59469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59470       };
59471     }
59472   }
59473
59474 }
59475
59476
59477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59479
59480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59481   {
59482     try {
59483       (arg1)->ClearBackground();
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59491       };
59492     } catch (Dali::DaliException e) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59495       };
59496     } catch (...) {
59497       {
59498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59499       };
59500     }
59501   }
59502
59503 }
59504
59505
59506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59508   Dali::Gesture::Type arg2 ;
59509
59510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59511   arg2 = (Dali::Gesture::Type)jarg2;
59512   {
59513     try {
59514       (arg1)->EnableGestureDetection(arg2);
59515     } catch (std::out_of_range& e) {
59516       {
59517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59518       };
59519     } catch (std::exception& e) {
59520       {
59521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59522       };
59523     } catch (Dali::DaliException e) {
59524       {
59525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59526       };
59527     } catch (...) {
59528       {
59529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59530       };
59531     }
59532   }
59533
59534 }
59535
59536
59537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59539   Dali::Gesture::Type arg2 ;
59540
59541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59542   arg2 = (Dali::Gesture::Type)jarg2;
59543   {
59544     try {
59545       (arg1)->DisableGestureDetection(arg2);
59546     } catch (std::out_of_range& e) {
59547       {
59548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59549       };
59550     } catch (std::exception& e) {
59551       {
59552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59553       };
59554     } catch (Dali::DaliException e) {
59555       {
59556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59561       };
59562     }
59563   }
59564
59565 }
59566
59567
59568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59569   void * jresult ;
59570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59571   Dali::PinchGestureDetector result;
59572
59573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59574   {
59575     try {
59576       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59577     } catch (std::out_of_range& e) {
59578       {
59579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59580       };
59581     } catch (std::exception& e) {
59582       {
59583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59584       };
59585     } catch (Dali::DaliException e) {
59586       {
59587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59588       };
59589     } catch (...) {
59590       {
59591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59592       };
59593     }
59594   }
59595
59596   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59597   return jresult;
59598 }
59599
59600
59601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59602   void * jresult ;
59603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59604   Dali::PanGestureDetector result;
59605
59606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59607   {
59608     try {
59609       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59610     } catch (std::out_of_range& e) {
59611       {
59612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59613       };
59614     } catch (std::exception& e) {
59615       {
59616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59617       };
59618     } catch (Dali::DaliException e) {
59619       {
59620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59621       };
59622     } catch (...) {
59623       {
59624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59625       };
59626     }
59627   }
59628
59629   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59630   return jresult;
59631 }
59632
59633
59634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59635   void * jresult ;
59636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59637   Dali::TapGestureDetector result;
59638
59639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59640   {
59641     try {
59642       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59643     } catch (std::out_of_range& e) {
59644       {
59645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (std::exception& e) {
59648       {
59649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59650       };
59651     } catch (Dali::DaliException e) {
59652       {
59653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59654       };
59655     } catch (...) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59658       };
59659     }
59660   }
59661
59662   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59663   return jresult;
59664 }
59665
59666
59667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59668   void * jresult ;
59669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59670   Dali::LongPressGestureDetector result;
59671
59672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59673   {
59674     try {
59675       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59676     } catch (std::out_of_range& e) {
59677       {
59678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59679       };
59680     } catch (std::exception& e) {
59681       {
59682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59683       };
59684     } catch (Dali::DaliException e) {
59685       {
59686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59687       };
59688     } catch (...) {
59689       {
59690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59691       };
59692     }
59693   }
59694
59695   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59696   return jresult;
59697 }
59698
59699
59700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59702   bool arg2 ;
59703
59704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59705   arg2 = jarg2 ? true : false;
59706   {
59707     try {
59708       (arg1)->SetKeyboardNavigationSupport(arg2);
59709     } catch (std::out_of_range& e) {
59710       {
59711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59712       };
59713     } catch (std::exception& e) {
59714       {
59715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59716       };
59717     } catch (Dali::DaliException e) {
59718       {
59719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59720       };
59721     } catch (...) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59724       };
59725     }
59726   }
59727
59728 }
59729
59730
59731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59732   unsigned int jresult ;
59733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59734   bool result;
59735
59736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59737   {
59738     try {
59739       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59740     } catch (std::out_of_range& e) {
59741       {
59742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (std::exception& e) {
59745       {
59746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (Dali::DaliException e) {
59749       {
59750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59751       };
59752     } catch (...) {
59753       {
59754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59755       };
59756     }
59757   }
59758
59759   jresult = result;
59760   return jresult;
59761 }
59762
59763
59764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59766
59767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59768   {
59769     try {
59770       (arg1)->SetKeyInputFocus();
59771     } catch (std::out_of_range& e) {
59772       {
59773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59774       };
59775     } catch (std::exception& e) {
59776       {
59777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59778       };
59779     } catch (Dali::DaliException e) {
59780       {
59781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59782       };
59783     } catch (...) {
59784       {
59785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59786       };
59787     }
59788   }
59789
59790 }
59791
59792
59793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59794   unsigned int jresult ;
59795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59796   bool result;
59797
59798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59799   {
59800     try {
59801       result = (bool)(arg1)->HasKeyInputFocus();
59802     } catch (std::out_of_range& e) {
59803       {
59804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59805       };
59806     } catch (std::exception& e) {
59807       {
59808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59809       };
59810     } catch (Dali::DaliException e) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59813       };
59814     } catch (...) {
59815       {
59816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59817       };
59818     }
59819   }
59820
59821   jresult = result;
59822   return jresult;
59823 }
59824
59825
59826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59828
59829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59830   {
59831     try {
59832       (arg1)->ClearKeyInputFocus();
59833     } catch (std::out_of_range& e) {
59834       {
59835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59836       };
59837     } catch (std::exception& e) {
59838       {
59839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59840       };
59841     } catch (Dali::DaliException e) {
59842       {
59843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59844       };
59845     } catch (...) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59848       };
59849     }
59850   }
59851
59852 }
59853
59854
59855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59857   bool arg2 ;
59858
59859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59860   arg2 = jarg2 ? true : false;
59861   {
59862     try {
59863       (arg1)->SetAsKeyboardFocusGroup(arg2);
59864     } catch (std::out_of_range& e) {
59865       {
59866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59867       };
59868     } catch (std::exception& e) {
59869       {
59870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59871       };
59872     } catch (Dali::DaliException e) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59875       };
59876     } catch (...) {
59877       {
59878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59879       };
59880     }
59881   }
59882
59883 }
59884
59885
59886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59887   unsigned int jresult ;
59888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59889   bool result;
59890
59891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59892   {
59893     try {
59894       result = (bool)(arg1)->IsKeyboardFocusGroup();
59895     } catch (std::out_of_range& e) {
59896       {
59897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59898       };
59899     } catch (std::exception& e) {
59900       {
59901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59902       };
59903     } catch (Dali::DaliException e) {
59904       {
59905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59906       };
59907     } catch (...) {
59908       {
59909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59910       };
59911     }
59912   }
59913
59914   jresult = result;
59915   return jresult;
59916 }
59917
59918
59919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59920   void * jresult ;
59921   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59922   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59923
59924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59925   {
59926     try {
59927       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59928     } catch (std::out_of_range& e) {
59929       {
59930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59931       };
59932     } catch (std::exception& e) {
59933       {
59934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59935       };
59936     } catch (Dali::DaliException e) {
59937       {
59938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59939       };
59940     } catch (...) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59943       };
59944     }
59945   }
59946
59947   jresult = (void *)result;
59948   return jresult;
59949 }
59950
59951
59952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59953   void * jresult ;
59954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59955   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59956
59957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59958   {
59959     try {
59960       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59961     } catch (std::out_of_range& e) {
59962       {
59963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59964       };
59965     } catch (std::exception& e) {
59966       {
59967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (Dali::DaliException e) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59972       };
59973     } catch (...) {
59974       {
59975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59976       };
59977     }
59978   }
59979
59980   jresult = (void *)result;
59981   return jresult;
59982 }
59983
59984
59985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59986   void * jresult ;
59987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59988   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59989
59990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59991   {
59992     try {
59993       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59994     } catch (std::out_of_range& e) {
59995       {
59996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59997       };
59998     } catch (std::exception& e) {
59999       {
60000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60001       };
60002     } catch (Dali::DaliException e) {
60003       {
60004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60005       };
60006     } catch (...) {
60007       {
60008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60009       };
60010     }
60011   }
60012
60013   jresult = (void *)result;
60014   return jresult;
60015 }
60016
60017
60018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
60019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60020   int arg2 ;
60021   SwigDirector_ViewImpl *darg = 0;
60022
60023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60024   arg2 = (int)jarg2;
60025   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60026   if(!darg) {
60027     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60028     return;
60029   }
60030   {
60031     try {
60032       if(darg) {
60033         (darg)->OnSceneConnection(arg2);
60034       }
60035     } catch (std::out_of_range& e) {
60036       {
60037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60038       };
60039     } catch (std::exception& e) {
60040       {
60041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60042       };
60043     } catch (Dali::DaliException e) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60046       };
60047     } catch (...) {
60048       {
60049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60050       };
60051     }
60052   }
60053
60054 }
60055
60056
60057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60059   int arg2 ;
60060   SwigDirector_ViewImpl *darg = 0;
60061
60062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60063   arg2 = (int)jarg2;
60064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60065   if(!darg) {
60066     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60067     return;
60068   }
60069   {
60070     try {
60071       if(darg) {
60072         (darg)->OnSceneConnectionSwigPublic(arg2);
60073       }
60074     } catch (std::out_of_range& e) {
60075       {
60076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60077       };
60078     } catch (std::exception& e) {
60079       {
60080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60081       };
60082     } catch (Dali::DaliException e) {
60083       {
60084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60085       };
60086     } catch (...) {
60087       {
60088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60089       };
60090     }
60091   }
60092
60093 }
60094
60095
60096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
60097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60098   SwigDirector_ViewImpl *darg = 0;
60099
60100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60101   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60102   if(!darg) {
60103     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60104     return;
60105   }
60106   {
60107     try {
60108       if(darg) {
60109         (darg)->OnSceneDisconnection();
60110       }
60111     } catch (std::out_of_range& e) {
60112       {
60113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60114       };
60115     } catch (std::exception& e) {
60116       {
60117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60118       };
60119     } catch (Dali::DaliException e) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60122       };
60123     } catch (...) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60126       };
60127     }
60128   }
60129
60130 }
60131
60132
60133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60135   SwigDirector_ViewImpl *darg = 0;
60136
60137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60138   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60139   if(!darg) {
60140     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60141     return;
60142   }
60143   {
60144     try {
60145       if(darg) {
60146         (darg)->OnSceneDisconnectionSwigPublic();
60147       }
60148     } catch (std::out_of_range& e) {
60149       {
60150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60151       };
60152     } catch (std::exception& e) {
60153       {
60154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60155       };
60156     } catch (Dali::DaliException e) {
60157       {
60158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60159       };
60160     } catch (...) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60163       };
60164     }
60165   }
60166
60167 }
60168
60169
60170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60172   Dali::Actor *arg2 = 0 ;
60173   SwigDirector_ViewImpl *darg = 0;
60174
60175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60176   arg2 = (Dali::Actor *)jarg2;
60177   if (!arg2) {
60178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60179     return ;
60180   }
60181   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60182   if(!darg) {
60183     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60184     return;
60185   }
60186   {
60187     try {
60188       if(darg) {
60189         (darg)->OnChildAdd(*arg2);
60190       }
60191     } catch (std::out_of_range& e) {
60192       {
60193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60194       };
60195     } catch (std::exception& e) {
60196       {
60197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60198       };
60199     } catch (Dali::DaliException e) {
60200       {
60201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60202       };
60203     } catch (...) {
60204       {
60205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60206       };
60207     }
60208   }
60209
60210 }
60211
60212
60213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60215   Dali::Actor *arg2 = 0 ;
60216   SwigDirector_ViewImpl *darg = 0;
60217
60218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60219   arg2 = (Dali::Actor *)jarg2;
60220   if (!arg2) {
60221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60222     return ;
60223   }
60224   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60225   if(!darg) {
60226     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60227     return;
60228   }
60229   {
60230     try {
60231       if(darg) {
60232           (darg)->OnChildAddSwigPublic(*arg2);
60233       }
60234     } catch (std::out_of_range& e) {
60235       {
60236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60237       };
60238     } catch (std::exception& e) {
60239       {
60240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60241       };
60242     } catch (Dali::DaliException e) {
60243       {
60244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60245       };
60246     } catch (...) {
60247       {
60248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60249       };
60250     }
60251   }
60252
60253 }
60254
60255
60256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60258   Dali::Actor *arg2 = 0 ;
60259   SwigDirector_ViewImpl *darg = 0;
60260
60261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60262   arg2 = (Dali::Actor *)jarg2;
60263   if (!arg2) {
60264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60265     return ;
60266   }
60267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60268   if(!darg) {
60269     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60270     return;
60271   }
60272   {
60273     try {
60274       if(darg) {
60275         (darg)->OnChildRemove(*arg2);
60276       }
60277     } catch (std::out_of_range& e) {
60278       {
60279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60280       };
60281     } catch (std::exception& e) {
60282       {
60283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60284       };
60285     } catch (Dali::DaliException e) {
60286       {
60287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60288       };
60289     } catch (...) {
60290       {
60291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60292       };
60293     }
60294   }
60295
60296 }
60297
60298
60299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60300   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60301   Dali::Actor *arg2 = 0 ;
60302   SwigDirector_ViewImpl *darg = 0;
60303
60304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60305   arg2 = (Dali::Actor *)jarg2;
60306   if (!arg2) {
60307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60308     return ;
60309   }
60310   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60311   if(!darg) {
60312     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60313     return;
60314   }
60315   {
60316     try {
60317       if(darg) {
60318         (darg)->OnChildRemoveSwigPublic(*arg2);
60319       }
60320     } catch (std::out_of_range& e) {
60321       {
60322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60323       };
60324     } catch (std::exception& e) {
60325       {
60326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60327       };
60328     } catch (Dali::DaliException e) {
60329       {
60330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60335       };
60336     }
60337   }
60338
60339 }
60340
60341
60342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60344   Dali::Property::Index arg2 ;
60345   Dali::Property::Value arg3 ;
60346   Dali::Property::Value *argp3 ;
60347   SwigDirector_ViewImpl *darg = 0;
60348
60349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60350   arg2 = (Dali::Property::Index)jarg2;
60351   argp3 = (Dali::Property::Value *)jarg3;
60352   if (!argp3) {
60353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60354     return ;
60355   }
60356   arg3 = *argp3;
60357   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60358   if (!darg) {
60359     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60360     return;
60361   }
60362   {
60363     try {
60364       (darg)->OnPropertySet(arg2,arg3);
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60372       };
60373     } catch (Dali::DaliException e) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60376       };
60377     } catch (...) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60380       };
60381     }
60382   }
60383
60384 }
60385
60386
60387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60389   Dali::Property::Index arg2 ;
60390   Dali::Property::Value arg3 ;
60391   Dali::Property::Value *argp3 ;
60392   SwigDirector_ViewImpl *darg = 0;
60393
60394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60395   arg2 = (Dali::Property::Index)jarg2;
60396   argp3 = (Dali::Property::Value *)jarg3;
60397   if (!argp3) {
60398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60399     return ;
60400   }
60401   arg3 = *argp3;
60402   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60403   if (!darg) {
60404     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60405     return;
60406   }
60407   {
60408     try {
60409       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60410     } catch (std::out_of_range& e) {
60411       {
60412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60413       };
60414     } catch (std::exception& e) {
60415       {
60416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60417       };
60418     } catch (Dali::DaliException e) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60421       };
60422     } catch (...) {
60423       {
60424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60425       };
60426     }
60427   }
60428
60429 }
60430
60431
60432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60434   Dali::Vector3 *arg2 = 0 ;
60435   SwigDirector_ViewImpl *darg = 0;
60436
60437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60438   arg2 = (Dali::Vector3 *)jarg2;
60439   if (!arg2) {
60440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60441     return ;
60442   }
60443   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60444   if (!darg) {
60445     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60446     return;
60447   }
60448   {
60449     try {
60450       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60451     } catch (std::out_of_range& e) {
60452       {
60453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60454       };
60455     } catch (std::exception& e) {
60456       {
60457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60458       };
60459     } catch (Dali::DaliException e) {
60460       {
60461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60462       };
60463     } catch (...) {
60464       {
60465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60466       };
60467     }
60468   }
60469
60470 }
60471
60472
60473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60475   Dali::Vector3 *arg2 = 0 ;
60476   SwigDirector_ViewImpl *darg = 0;
60477
60478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60479   arg2 = (Dali::Vector3 *)jarg2;
60480   if (!arg2) {
60481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60482     return ;
60483   }
60484   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60485   if (!darg) {
60486     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60487     return;
60488   }
60489   {
60490     try {
60491       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60492     } catch (std::out_of_range& e) {
60493       {
60494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60495       };
60496     } catch (std::exception& e) {
60497       {
60498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60499       };
60500     } catch (Dali::DaliException e) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60503       };
60504     } catch (...) {
60505       {
60506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60507       };
60508     }
60509   }
60510
60511 }
60512
60513
60514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60515   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60516   Dali::Animation *arg2 = 0 ;
60517   Dali::Vector3 *arg3 = 0 ;
60518   SwigDirector_ViewImpl *darg = 0;
60519
60520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60521   arg2 = (Dali::Animation *)jarg2;
60522   if (!arg2) {
60523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60524     return ;
60525   }
60526   arg3 = (Dali::Vector3 *)jarg3;
60527   if (!arg3) {
60528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60529     return ;
60530   }
60531   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60532   if (!darg) {
60533     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60534     return;
60535   }
60536   {
60537     try {
60538       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60539     } catch (std::out_of_range& e) {
60540       {
60541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60542       };
60543     } catch (std::exception& e) {
60544       {
60545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60546       };
60547     } catch (Dali::DaliException e) {
60548       {
60549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60550       };
60551     } catch (...) {
60552       {
60553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60554       };
60555     }
60556   }
60557
60558 }
60559
60560
60561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60563   Dali::Animation *arg2 = 0 ;
60564   Dali::Vector3 *arg3 = 0 ;
60565   SwigDirector_ViewImpl *darg = 0;
60566
60567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60568   arg2 = (Dali::Animation *)jarg2;
60569   if (!arg2) {
60570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60571     return ;
60572   }
60573   arg3 = (Dali::Vector3 *)jarg3;
60574   if (!arg3) {
60575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60576     return ;
60577   }
60578   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60579   if (!darg) {
60580     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60581     return;
60582   }
60583   {
60584     try {
60585       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60586     } catch (std::out_of_range& e) {
60587       {
60588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60589       };
60590     } catch (std::exception& e) {
60591       {
60592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60593       };
60594     } catch (Dali::DaliException e) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60597       };
60598     } catch (...) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60601       };
60602     }
60603   }
60604 }
60605
60606
60607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60608   unsigned int jresult ;
60609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60610   Dali::HoverEvent *arg2 = 0 ;
60611   SwigDirector_ViewImpl *darg = 0;
60612   bool result;
60613
60614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60615   arg2 = (Dali::HoverEvent *)jarg2;
60616   if (!arg2) {
60617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60618     return 0;
60619   }
60620   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60621   if (!darg) {
60622     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60623     return 0;
60624   }
60625   {
60626     try {
60627       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60628     } catch (std::out_of_range& e) {
60629       {
60630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60631       };
60632     } catch (std::exception& e) {
60633       {
60634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60635       };
60636     } catch (Dali::DaliException e) {
60637       {
60638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60639       };
60640     } catch (...) {
60641       {
60642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60643       };
60644     }
60645   }
60646
60647   jresult = result;
60648   return jresult;
60649 }
60650
60651
60652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60653   unsigned int jresult ;
60654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60655   Dali::HoverEvent *arg2 = 0 ;
60656   SwigDirector_ViewImpl *darg = 0;
60657   bool result;
60658
60659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60660   arg2 = (Dali::HoverEvent *)jarg2;
60661   if (!arg2) {
60662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60663     return 0;
60664   }
60665   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60666   if (!darg) {
60667     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60668     return 0;
60669   }
60670   {
60671     try {
60672       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60673     } catch (std::out_of_range& e) {
60674       {
60675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (std::exception& e) {
60678       {
60679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60680       };
60681     } catch (Dali::DaliException e) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60684       };
60685     } catch (...) {
60686       {
60687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60688       };
60689     }
60690   }
60691
60692   jresult = result;
60693   return jresult;
60694 }
60695
60696
60697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60698   unsigned int jresult ;
60699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60700   Dali::KeyEvent *arg2 = 0 ;
60701   SwigDirector_ViewImpl *darg = 0;
60702   bool result;
60703
60704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60705   arg2 = (Dali::KeyEvent *)jarg2;
60706   if (!arg2) {
60707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60708     return 0;
60709   }
60710   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60711   if (!darg) {
60712     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60713     return 0;
60714   }
60715   {
60716     try {
60717       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60718     } catch (std::out_of_range& e) {
60719       {
60720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60721       };
60722     } catch (std::exception& e) {
60723       {
60724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60725       };
60726     } catch (Dali::DaliException e) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60729       };
60730     } catch (...) {
60731       {
60732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60733       };
60734     }
60735   }
60736
60737   jresult = result;
60738   return jresult;
60739 }
60740
60741
60742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60743   unsigned int jresult ;
60744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60745   Dali::KeyEvent *arg2 = 0 ;
60746   SwigDirector_ViewImpl *darg = 0;
60747   bool result;
60748
60749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60750   arg2 = (Dali::KeyEvent *)jarg2;
60751   if (!arg2) {
60752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60753     return 0;
60754   }
60755   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60756   if (!darg) {
60757     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60758     return 0;
60759   }
60760   {
60761     try {
60762       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60763     } catch (std::out_of_range& e) {
60764       {
60765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60766       };
60767     } catch (std::exception& e) {
60768       {
60769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60770       };
60771     } catch (Dali::DaliException e) {
60772       {
60773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60774       };
60775     } catch (...) {
60776       {
60777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60778       };
60779     }
60780   }
60781
60782   jresult = result;
60783   return jresult;
60784 }
60785
60786
60787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60788   unsigned int jresult ;
60789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60790   Dali::WheelEvent *arg2 = 0 ;
60791   SwigDirector_ViewImpl *darg = 0;
60792   bool result;
60793
60794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60795   arg2 = (Dali::WheelEvent *)jarg2;
60796   if (!arg2) {
60797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60798     return 0;
60799   }
60800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60801   if (!darg) {
60802     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60803     return 0;
60804   }
60805   {
60806     try {
60807       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60808     } catch (std::out_of_range& e) {
60809       {
60810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60811       };
60812     } catch (std::exception& e) {
60813       {
60814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60815       };
60816     } catch (Dali::DaliException e) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60819       };
60820     } catch (...) {
60821       {
60822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60823       };
60824     }
60825   }
60826
60827   jresult = result;
60828   return jresult;
60829 }
60830
60831
60832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60833   unsigned int jresult ;
60834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60835   Dali::WheelEvent *arg2 = 0 ;
60836   SwigDirector_ViewImpl *darg = 0;
60837   bool result;
60838
60839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60840   arg2 = (Dali::WheelEvent *)jarg2;
60841   if (!arg2) {
60842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60843     return 0;
60844   }
60845   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60846   if (!darg) {
60847     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60848     return 0;
60849   }
60850   {
60851     try {
60852       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (Dali::DaliException e) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60868       };
60869     }
60870   }
60871
60872   jresult = result;
60873   return jresult;
60874 }
60875
60876
60877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60879   Dali::Vector2 *arg2 = 0 ;
60880   Dali::RelayoutContainer *arg3 = 0 ;
60881   SwigDirector_ViewImpl *darg = 0;
60882
60883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60884   arg2 = (Dali::Vector2 *)jarg2;
60885   if (!arg2) {
60886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60887     return ;
60888   }
60889   arg3 = (Dali::RelayoutContainer *)jarg3;
60890   if (!arg3) {
60891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60892     return ;
60893   }
60894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60895   if (!darg) {
60896     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60897     return;
60898   }
60899   {
60900     try {
60901       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60902     } catch (std::out_of_range& e) {
60903       {
60904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60905       };
60906     } catch (std::exception& e) {
60907       {
60908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60909       };
60910     } catch (Dali::DaliException e) {
60911       {
60912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60913       };
60914     } catch (...) {
60915       {
60916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60917       };
60918     }
60919   }
60920
60921 }
60922
60923
60924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60926   Dali::Vector2 *arg2 = 0 ;
60927   Dali::RelayoutContainer *arg3 = 0 ;
60928   SwigDirector_ViewImpl *darg = 0;
60929
60930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60931   arg2 = (Dali::Vector2 *)jarg2;
60932   if (!arg2) {
60933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60934     return ;
60935   }
60936   arg3 = (Dali::RelayoutContainer *)jarg3;
60937   if (!arg3) {
60938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60939     return ;
60940   }
60941   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60942   if (!darg) {
60943     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60944     return;
60945   }
60946   {
60947     try {
60948       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60949     } catch (std::out_of_range& e) {
60950       {
60951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60952       };
60953     } catch (std::exception& e) {
60954       {
60955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60956       };
60957     } catch (Dali::DaliException e) {
60958       {
60959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60960       };
60961     } catch (...) {
60962       {
60963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60964       };
60965     }
60966   }
60967
60968 }
60969
60970
60971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60973   Dali::ResizePolicy::Type arg2 ;
60974   Dali::Dimension::Type arg3 ;
60975   SwigDirector_ViewImpl *darg = 0;
60976
60977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60978   arg2 = (Dali::ResizePolicy::Type)jarg2;
60979   arg3 = (Dali::Dimension::Type)jarg3;
60980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60981   if (!darg) {
60982     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60983     return;
60984   }
60985   {
60986     try {
60987       (darg)->OnSetResizePolicy(arg2,arg3);
60988     } catch (std::out_of_range& e) {
60989       {
60990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60991       };
60992     } catch (std::exception& e) {
60993       {
60994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60995       };
60996     } catch (Dali::DaliException e) {
60997       {
60998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60999       };
61000     } catch (...) {
61001       {
61002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61003       };
61004     }
61005   }
61006
61007 }
61008
61009
61010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61012   Dali::ResizePolicy::Type arg2 ;
61013   Dali::Dimension::Type arg3 ;
61014   SwigDirector_ViewImpl *darg = 0;
61015
61016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61017   arg2 = (Dali::ResizePolicy::Type)jarg2;
61018   arg3 = (Dali::Dimension::Type)jarg3;
61019   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61020   if (!darg) {
61021     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61022     return;
61023   }
61024   {
61025     try {
61026       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61027     } catch (std::out_of_range& e) {
61028       {
61029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61030       };
61031     } catch (std::exception& e) {
61032       {
61033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61034       };
61035     } catch (Dali::DaliException e) {
61036       {
61037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61038       };
61039     } catch (...) {
61040       {
61041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61042       };
61043     }
61044   }
61045
61046 }
61047
61048
61049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61050   void * jresult ;
61051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61052   SwigDirector_ViewImpl *darg = 0;
61053   Dali::Vector3 result;
61054
61055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61057   if (!darg) {
61058     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61059     return 0;
61060   }
61061   {
61062     try {
61063       result = (darg)->GetNaturalSize();
61064     } catch (std::out_of_range& e) {
61065       {
61066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61067       };
61068     } catch (std::exception& e) {
61069       {
61070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (Dali::DaliException e) {
61073       {
61074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61079       };
61080     }
61081   }
61082
61083   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61084   return jresult;
61085 }
61086
61087
61088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61089   void * jresult ;
61090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61091   SwigDirector_ViewImpl *darg = 0;
61092   Dali::Vector3 result;
61093
61094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61095   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61096   if (!darg) {
61097     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61098     return 0;
61099   }
61100   {
61101     try {
61102       result = (darg)->GetNaturalSizeSwigPublic();
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (Dali::DaliException e) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61114       };
61115     } catch (...) {
61116       {
61117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61118       };
61119     }
61120   }
61121
61122   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61123   return jresult;
61124 }
61125
61126
61127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61128   float jresult ;
61129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61130   Dali::Actor *arg2 = 0 ;
61131   Dali::Dimension::Type arg3 ;
61132   SwigDirector_ViewImpl *darg = 0;
61133   float result;
61134
61135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61136   arg2 = (Dali::Actor *)jarg2;
61137   if (!arg2) {
61138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61139     return 0;
61140   }
61141   arg3 = (Dali::Dimension::Type)jarg3;
61142   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61143   if (!darg) {
61144     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61145     return 0;
61146   }
61147   {
61148     try {
61149       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61150     } catch (std::out_of_range& e) {
61151       {
61152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61153       };
61154     } catch (std::exception& e) {
61155       {
61156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61157       };
61158     } catch (Dali::DaliException e) {
61159       {
61160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61161       };
61162     } catch (...) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61165       };
61166     }
61167   }
61168
61169   jresult = result;
61170   return jresult;
61171 }
61172
61173
61174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61175   float jresult ;
61176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61177   Dali::Actor *arg2 = 0 ;
61178   Dali::Dimension::Type arg3 ;
61179   SwigDirector_ViewImpl *darg = 0;
61180   float result;
61181
61182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61183   arg2 = (Dali::Actor *)jarg2;
61184   if (!arg2) {
61185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61186     return 0;
61187   }
61188   arg3 = (Dali::Dimension::Type)jarg3;
61189   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61190   if (!darg) {
61191     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61192     return 0;
61193   }
61194   {
61195     try {
61196       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61197     } catch (std::out_of_range& e) {
61198       {
61199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61200       };
61201     } catch (std::exception& e) {
61202       {
61203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61204       };
61205     } catch (Dali::DaliException e) {
61206       {
61207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61208       };
61209     } catch (...) {
61210       {
61211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61212       };
61213     }
61214   }
61215
61216   jresult = result;
61217   return jresult;
61218 }
61219
61220
61221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61222   float jresult ;
61223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61224   float arg2 ;
61225   SwigDirector_ViewImpl *darg = 0;
61226   float result;
61227
61228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61229   arg2 = (float)jarg2;
61230   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61231   if (!darg) {
61232     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61233     return 0;
61234   }
61235   {
61236     try {
61237       result = (float)(darg)->GetHeightForWidth(arg2);
61238     } catch (std::out_of_range& e) {
61239       {
61240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61241       };
61242     } catch (std::exception& e) {
61243       {
61244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61245       };
61246     } catch (Dali::DaliException e) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61253       };
61254     }
61255   }
61256
61257   jresult = result;
61258   return jresult;
61259 }
61260
61261
61262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61263   float jresult ;
61264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61265   float arg2 ;
61266   SwigDirector_ViewImpl *darg = 0;
61267   float result;
61268
61269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61270   arg2 = (float)jarg2;
61271   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61272   if (!darg) {
61273     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61274     return 0;
61275   }
61276   {
61277     try {
61278       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61279     } catch (std::out_of_range& e) {
61280       {
61281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61282       };
61283     } catch (std::exception& e) {
61284       {
61285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61286       };
61287     } catch (Dali::DaliException e) {
61288       {
61289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61290       };
61291     } catch (...) {
61292       {
61293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61294       };
61295     }
61296   }
61297
61298   jresult = result;
61299   return jresult;
61300 }
61301
61302
61303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61304   float jresult ;
61305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61306   float arg2 ;
61307   SwigDirector_ViewImpl *darg = 0;
61308   float result;
61309
61310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61311   arg2 = (float)jarg2;
61312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61313   if (!darg) {
61314     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61315     return 0;
61316   }
61317   {
61318     try {
61319       result = (float)(darg)->GetWidthForHeight(arg2);
61320     } catch (std::out_of_range& e) {
61321       {
61322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61323       };
61324     } catch (std::exception& e) {
61325       {
61326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61327       };
61328     } catch (Dali::DaliException e) {
61329       {
61330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61331       };
61332     } catch (...) {
61333       {
61334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61335       };
61336     }
61337   }
61338
61339   jresult = result;
61340   return jresult;
61341 }
61342
61343
61344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61345   float jresult ;
61346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61347   float arg2 ;
61348   SwigDirector_ViewImpl *darg = 0;
61349   float result;
61350
61351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61352   arg2 = (float)jarg2;
61353   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61354   if (!darg) {
61355     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61356     return 0;
61357   }
61358   {
61359     try {
61360       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (Dali::DaliException e) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61372       };
61373     } catch (...) {
61374       {
61375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61376       };
61377     }
61378   }
61379
61380   jresult = result;
61381   return jresult;
61382 }
61383
61384
61385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61386   unsigned int jresult ;
61387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61388   Dali::Dimension::Type arg2 ;
61389   SwigDirector_ViewImpl *darg = 0;
61390   bool result;
61391
61392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61393   arg2 = (Dali::Dimension::Type)jarg2;
61394   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61395   if (!darg) {
61396     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61397     return 0;
61398   }
61399   {
61400     try {
61401       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61402     } catch (std::out_of_range& e) {
61403       {
61404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61405       };
61406     } catch (std::exception& e) {
61407       {
61408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61409       };
61410     } catch (Dali::DaliException e) {
61411       {
61412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61413       };
61414     } catch (...) {
61415       {
61416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61417       };
61418     }
61419   }
61420
61421   jresult = result;
61422   return jresult;
61423 }
61424
61425
61426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61427   unsigned int jresult ;
61428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61429   Dali::Dimension::Type arg2 ;
61430   SwigDirector_ViewImpl *darg = 0;
61431   bool result;
61432
61433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61434   arg2 = (Dali::Dimension::Type)jarg2;
61435   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61436   if (!darg) {
61437     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61438     return 0;
61439   }
61440   {
61441     try {
61442       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61443     } catch (std::out_of_range& e) {
61444       {
61445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61446       };
61447     } catch (std::exception& e) {
61448       {
61449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61450       };
61451     } catch (Dali::DaliException e) {
61452       {
61453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61454       };
61455     } catch (...) {
61456       {
61457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61458       };
61459     }
61460   }
61461
61462   jresult = result;
61463   return jresult;
61464 }
61465
61466
61467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61468   unsigned int jresult ;
61469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61470   SwigDirector_ViewImpl *darg = 0;
61471   bool result;
61472
61473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61474   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61475   if (!darg) {
61476     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61477     return 0;
61478   }
61479   {
61480     try {
61481       result = (bool)(darg)->RelayoutDependentOnChildren();
61482     } catch (std::out_of_range& e) {
61483       {
61484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61485       };
61486     } catch (std::exception& e) {
61487       {
61488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (Dali::DaliException e) {
61491       {
61492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61493       };
61494     } catch (...) {
61495       {
61496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61497       };
61498     }
61499   }
61500
61501   jresult = result;
61502   return jresult;
61503 }
61504
61505
61506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61507   unsigned int jresult ;
61508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61509   SwigDirector_ViewImpl *darg = 0;
61510   bool result;
61511
61512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61514   if (!darg) {
61515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61516     return 0;
61517   }
61518   {
61519     try {
61520       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61521     } catch (std::out_of_range& e) {
61522       {
61523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61524       };
61525     } catch (std::exception& e) {
61526       {
61527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61528       };
61529     } catch (Dali::DaliException e) {
61530       {
61531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61532       };
61533     } catch (...) {
61534       {
61535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61536       };
61537     }
61538   }
61539
61540   jresult = result;
61541   return jresult;
61542 }
61543
61544
61545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61547   Dali::Dimension::Type arg2 ;
61548   SwigDirector_ViewImpl *darg = 0;
61549
61550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61551   arg2 = (Dali::Dimension::Type)jarg2;
61552   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61553   if (!darg) {
61554     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61555     return;
61556   }
61557   {
61558     try {
61559       (darg)->OnCalculateRelayoutSize(arg2);
61560     } catch (std::out_of_range& e) {
61561       {
61562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61563       };
61564     } catch (std::exception& e) {
61565       {
61566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61567       };
61568     } catch (Dali::DaliException e) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61571       };
61572     } catch (...) {
61573       {
61574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61575       };
61576     }
61577   }
61578
61579 }
61580
61581
61582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61584   Dali::Dimension::Type arg2 ;
61585   SwigDirector_ViewImpl *darg = 0;
61586
61587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61588   arg2 = (Dali::Dimension::Type)jarg2;
61589   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61590   if (!darg) {
61591     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61592     return;
61593   }
61594   {
61595     try {
61596       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61597     } catch (std::out_of_range& e) {
61598       {
61599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61600       };
61601     } catch (std::exception& e) {
61602       {
61603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61604       };
61605     } catch (Dali::DaliException e) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61612       };
61613     }
61614   }
61615
61616 }
61617
61618
61619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61621   float arg2 ;
61622   Dali::Dimension::Type arg3 ;
61623   SwigDirector_ViewImpl *darg = 0;
61624
61625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61626   arg2 = (float)jarg2;
61627   arg3 = (Dali::Dimension::Type)jarg3;
61628   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61629   if (!darg) {
61630     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61631     return;
61632   }
61633   {
61634     try {
61635       (darg)->OnLayoutNegotiated(arg2,arg3);
61636     } catch (std::out_of_range& e) {
61637       {
61638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61639       };
61640     } catch (std::exception& e) {
61641       {
61642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61643       };
61644     } catch (Dali::DaliException e) {
61645       {
61646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61647       };
61648     } catch (...) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61651       };
61652     }
61653   }
61654
61655 }
61656
61657
61658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61660   float arg2 ;
61661   Dali::Dimension::Type arg3 ;
61662   SwigDirector_ViewImpl *darg = 0;
61663
61664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61665   arg2 = (float)jarg2;
61666   arg3 = (Dali::Dimension::Type)jarg3;
61667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61668   if (!darg) {
61669     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61670     return;
61671   }
61672   {
61673     try {
61674       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61675     } catch (std::out_of_range& e) {
61676       {
61677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61678       };
61679     } catch (std::exception& e) {
61680       {
61681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61682       };
61683     } catch (Dali::DaliException e) {
61684       {
61685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61686       };
61687     } catch (...) {
61688       {
61689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61690       };
61691     }
61692   }
61693
61694 }
61695
61696
61697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61699
61700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61701   {
61702     try {
61703       (arg1)->OnInitialize();
61704     } catch (std::out_of_range& e) {
61705       {
61706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61707       };
61708     } catch (std::exception& e) {
61709       {
61710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61711       };
61712     } catch (Dali::DaliException e) {
61713       {
61714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61715       };
61716     } catch (...) {
61717       {
61718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61719       };
61720     }
61721   }
61722
61723 }
61724
61725
61726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61728
61729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61730   {
61731     try {
61732       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61748       };
61749     }
61750   }
61751
61752 }
61753
61754
61755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61757   Dali::Toolkit::StyleManager arg2 ;
61758   Dali::StyleChange::Type arg3 ;
61759   Dali::Toolkit::StyleManager *argp2 ;
61760
61761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61762   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61763   if (!argp2) {
61764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61765     return ;
61766   }
61767   arg2 = *argp2;
61768   arg3 = (Dali::StyleChange::Type)jarg3;
61769   {
61770     try {
61771       (arg1)->OnStyleChange(arg2,arg3);
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_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61796   Dali::Toolkit::StyleManager arg2 ;
61797   Dali::StyleChange::Type arg3 ;
61798   Dali::Toolkit::StyleManager *argp2 ;
61799
61800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61801   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61802   if (!argp2) {
61803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61804     return ;
61805   }
61806   arg2 = *argp2;
61807   arg3 = (Dali::StyleChange::Type)jarg3;
61808   {
61809     try {
61810       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61811     } catch (std::out_of_range& e) {
61812       {
61813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61814       };
61815     } catch (std::exception& e) {
61816       {
61817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61818       };
61819     } catch (Dali::DaliException e) {
61820       {
61821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61822       };
61823     } catch (...) {
61824       {
61825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61826       };
61827     }
61828   }
61829
61830 }
61831
61832
61833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61834   unsigned int jresult ;
61835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61836   bool result;
61837
61838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61839   {
61840     try {
61841       result = (bool)(arg1)->OnAccessibilityActivated();
61842     } catch (std::out_of_range& e) {
61843       {
61844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61845       };
61846     } catch (std::exception& e) {
61847       {
61848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61849       };
61850     } catch (Dali::DaliException e) {
61851       {
61852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61857       };
61858     }
61859   }
61860
61861   jresult = result;
61862   return jresult;
61863 }
61864
61865
61866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61867   unsigned int jresult ;
61868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61869   bool result;
61870
61871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61872   {
61873     try {
61874       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61875     } catch (std::out_of_range& e) {
61876       {
61877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61878       };
61879     } catch (std::exception& e) {
61880       {
61881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61882       };
61883     } catch (Dali::DaliException e) {
61884       {
61885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61886       };
61887     } catch (...) {
61888       {
61889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61890       };
61891     }
61892   }
61893
61894   jresult = result;
61895   return jresult;
61896 }
61897
61898
61899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61900   unsigned int jresult ;
61901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61902   Dali::PanGesture arg2 ;
61903   Dali::PanGesture *argp2 ;
61904   bool result;
61905
61906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61907   argp2 = (Dali::PanGesture *)jarg2;
61908   if (!argp2) {
61909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61910     return 0;
61911   }
61912   arg2 = *argp2;
61913   {
61914     try {
61915       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61916     } catch (std::out_of_range& e) {
61917       {
61918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61919       };
61920     } catch (std::exception& e) {
61921       {
61922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61923       };
61924     } catch (Dali::DaliException e) {
61925       {
61926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61927       };
61928     } catch (...) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61931       };
61932     }
61933   }
61934
61935   jresult = result;
61936   return jresult;
61937 }
61938
61939
61940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61941   unsigned int jresult ;
61942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61943   Dali::PanGesture arg2 ;
61944   Dali::PanGesture *argp2 ;
61945   bool result;
61946
61947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61948   argp2 = (Dali::PanGesture *)jarg2;
61949   if (!argp2) {
61950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61951     return 0;
61952   }
61953   arg2 = *argp2;
61954   {
61955     try {
61956       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61957     } catch (std::out_of_range& e) {
61958       {
61959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61960       };
61961     } catch (std::exception& e) {
61962       {
61963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61964       };
61965     } catch (Dali::DaliException e) {
61966       {
61967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61968       };
61969     } catch (...) {
61970       {
61971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61972       };
61973     }
61974   }
61975
61976   jresult = result;
61977   return jresult;
61978 }
61979
61980
61981
61982
61983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61984   unsigned int jresult ;
61985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61986   bool arg2 ;
61987   bool result;
61988
61989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61990   arg2 = jarg2 ? true : false;
61991   {
61992     try {
61993       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61994     } catch (std::out_of_range& e) {
61995       {
61996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61997       };
61998     } catch (std::exception& e) {
61999       {
62000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62001       };
62002     } catch (Dali::DaliException e) {
62003       {
62004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62005       };
62006     } catch (...) {
62007       {
62008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62009       };
62010     }
62011   }
62012
62013   jresult = result;
62014   return jresult;
62015 }
62016
62017
62018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62019   unsigned int jresult ;
62020   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62021   bool arg2 ;
62022   bool result;
62023
62024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62025   arg2 = jarg2 ? true : false;
62026   {
62027     try {
62028       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62029     } catch (std::out_of_range& e) {
62030       {
62031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62032       };
62033     } catch (std::exception& e) {
62034       {
62035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62036       };
62037     } catch (Dali::DaliException e) {
62038       {
62039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62040       };
62041     } catch (...) {
62042       {
62043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62044       };
62045     }
62046   }
62047
62048   jresult = result;
62049   return jresult;
62050 }
62051
62052
62053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62054   unsigned int jresult ;
62055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62056   bool result;
62057
62058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62059   {
62060     try {
62061       result = (bool)(arg1)->OnAccessibilityZoom();
62062     } catch (std::out_of_range& e) {
62063       {
62064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62065       };
62066     } catch (std::exception& e) {
62067       {
62068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62069       };
62070     } catch (Dali::DaliException e) {
62071       {
62072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62073       };
62074     } catch (...) {
62075       {
62076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62077       };
62078     }
62079   }
62080
62081   jresult = result;
62082   return jresult;
62083 }
62084
62085
62086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62087   unsigned int jresult ;
62088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62089   bool result;
62090
62091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62092   {
62093     try {
62094       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62095     } catch (std::out_of_range& e) {
62096       {
62097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62098       };
62099     } catch (std::exception& e) {
62100       {
62101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (Dali::DaliException e) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62110       };
62111     }
62112   }
62113
62114   jresult = result;
62115   return jresult;
62116 }
62117
62118
62119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62121
62122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62123   {
62124     try {
62125       (arg1)->OnKeyInputFocusGained();
62126     } catch (std::out_of_range& e) {
62127       {
62128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62129       };
62130     } catch (std::exception& e) {
62131       {
62132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62133       };
62134     } catch (Dali::DaliException e) {
62135       {
62136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62137       };
62138     } catch (...) {
62139       {
62140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62141       };
62142     }
62143   }
62144
62145 }
62146
62147
62148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62150
62151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62152   {
62153     try {
62154       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62155     } catch (std::out_of_range& e) {
62156       {
62157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62158       };
62159     } catch (std::exception& e) {
62160       {
62161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62162       };
62163     } catch (Dali::DaliException e) {
62164       {
62165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62166       };
62167     } catch (...) {
62168       {
62169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62170       };
62171     }
62172   }
62173
62174 }
62175
62176
62177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62179
62180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62181   {
62182     try {
62183       (arg1)->OnKeyInputFocusLost();
62184     } catch (std::out_of_range& e) {
62185       {
62186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62187       };
62188     } catch (std::exception& e) {
62189       {
62190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62191       };
62192     } catch (Dali::DaliException e) {
62193       {
62194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62195       };
62196     } catch (...) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62199       };
62200     }
62201   }
62202
62203 }
62204
62205
62206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62208
62209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62210   {
62211     try {
62212       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62213     } catch (std::out_of_range& e) {
62214       {
62215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62216       };
62217     } catch (std::exception& e) {
62218       {
62219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62220       };
62221     } catch (Dali::DaliException e) {
62222       {
62223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62224       };
62225     } catch (...) {
62226       {
62227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62228       };
62229     }
62230   }
62231
62232 }
62233
62234
62235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62236   void * jresult ;
62237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62238   Dali::Actor arg2 ;
62239   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62240   bool arg4 ;
62241   Dali::Actor *argp2 ;
62242   Dali::Actor result;
62243
62244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62245   argp2 = (Dali::Actor *)jarg2;
62246   if (!argp2) {
62247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62248     return 0;
62249   }
62250   arg2 = *argp2;
62251   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62252   arg4 = jarg4 ? true : false;
62253   {
62254     try {
62255       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62256     } catch (std::out_of_range& e) {
62257       {
62258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (std::exception& e) {
62261       {
62262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62263       };
62264     } catch (Dali::DaliException e) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62267       };
62268     } catch (...) {
62269       {
62270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62271       };
62272     }
62273   }
62274
62275   jresult = new Dali::Actor((const Dali::Actor &)result);
62276   return jresult;
62277 }
62278
62279
62280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62281   void * jresult ;
62282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62283   Dali::Actor arg2 ;
62284   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62285   bool arg4 ;
62286   Dali::Actor *argp2 ;
62287   Dali::Actor result;
62288
62289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62290   argp2 = (Dali::Actor *)jarg2;
62291   if (!argp2) {
62292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62293     return 0;
62294   }
62295   arg2 = *argp2;
62296   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62297   arg4 = jarg4 ? true : false;
62298   {
62299     try {
62300       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62301     } catch (std::out_of_range& e) {
62302       {
62303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62304       };
62305     } catch (std::exception& e) {
62306       {
62307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62308       };
62309     } catch (Dali::DaliException e) {
62310       {
62311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62312       };
62313     } catch (...) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62316       };
62317     }
62318   }
62319
62320   jresult = new Dali::Actor((const Dali::Actor &)result);
62321   return jresult;
62322 }
62323
62324
62325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62327   Dali::Actor arg2 ;
62328   Dali::Actor *argp2 ;
62329
62330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62331   argp2 = (Dali::Actor *)jarg2;
62332   if (!argp2) {
62333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62334     return ;
62335   }
62336   arg2 = *argp2;
62337   {
62338     try {
62339       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62340     } catch (std::out_of_range& e) {
62341       {
62342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62343       };
62344     } catch (std::exception& e) {
62345       {
62346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62347       };
62348     } catch (Dali::DaliException e) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62351       };
62352     } catch (...) {
62353       {
62354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62355       };
62356     }
62357   }
62358
62359 }
62360
62361
62362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62364   Dali::Actor arg2 ;
62365   Dali::Actor *argp2 ;
62366
62367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62368   argp2 = (Dali::Actor *)jarg2;
62369   if (!argp2) {
62370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62371     return ;
62372   }
62373   arg2 = *argp2;
62374   {
62375     try {
62376       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62377     } catch (std::out_of_range& e) {
62378       {
62379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62380       };
62381     } catch (std::exception& e) {
62382       {
62383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62384       };
62385     } catch (Dali::DaliException e) {
62386       {
62387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62388       };
62389     } catch (...) {
62390       {
62391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62392       };
62393     }
62394   }
62395
62396 }
62397
62398
62399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62400   unsigned int jresult ;
62401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62402   bool result;
62403
62404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62405   {
62406     try {
62407       result = (bool)(arg1)->OnKeyboardEnter();
62408     } catch (std::out_of_range& e) {
62409       {
62410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62411       };
62412     } catch (std::exception& e) {
62413       {
62414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62415       };
62416     } catch (Dali::DaliException e) {
62417       {
62418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62419       };
62420     } catch (...) {
62421       {
62422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62423       };
62424     }
62425   }
62426
62427   jresult = result;
62428   return jresult;
62429 }
62430
62431
62432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62433   unsigned int jresult ;
62434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62435   bool result;
62436
62437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62438   {
62439     try {
62440       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62441     } catch (std::out_of_range& e) {
62442       {
62443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62444       };
62445     } catch (std::exception& e) {
62446       {
62447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62448       };
62449     } catch (Dali::DaliException e) {
62450       {
62451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62452       };
62453     } catch (...) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62456       };
62457     }
62458   }
62459
62460   jresult = result;
62461   return jresult;
62462 }
62463
62464
62465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62467   Dali::PinchGesture *arg2 = 0 ;
62468
62469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62470   arg2 = (Dali::PinchGesture *)jarg2;
62471   if (!arg2) {
62472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62473     return ;
62474   }
62475   {
62476     try {
62477       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62478     } catch (std::out_of_range& e) {
62479       {
62480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62481       };
62482     } catch (std::exception& e) {
62483       {
62484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62485       };
62486     } catch (Dali::DaliException e) {
62487       {
62488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62489       };
62490     } catch (...) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62493       };
62494     }
62495   }
62496
62497 }
62498
62499
62500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62502   Dali::PinchGesture *arg2 = 0 ;
62503
62504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62505   arg2 = (Dali::PinchGesture *)jarg2;
62506   if (!arg2) {
62507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62508     return ;
62509   }
62510   {
62511     try {
62512       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62513     } catch (std::out_of_range& e) {
62514       {
62515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62516       };
62517     } catch (std::exception& e) {
62518       {
62519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62520       };
62521     } catch (Dali::DaliException e) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62524       };
62525     } catch (...) {
62526       {
62527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62528       };
62529     }
62530   }
62531
62532 }
62533
62534
62535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62537   Dali::PanGesture *arg2 = 0 ;
62538
62539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62540   arg2 = (Dali::PanGesture *)jarg2;
62541   if (!arg2) {
62542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62543     return ;
62544   }
62545   {
62546     try {
62547       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62548     } catch (std::out_of_range& e) {
62549       {
62550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62551       };
62552     } catch (std::exception& e) {
62553       {
62554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62555       };
62556     } catch (Dali::DaliException e) {
62557       {
62558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62559       };
62560     } catch (...) {
62561       {
62562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62563       };
62564     }
62565   }
62566
62567 }
62568
62569
62570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62572   Dali::PanGesture *arg2 = 0 ;
62573
62574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62575   arg2 = (Dali::PanGesture *)jarg2;
62576   if (!arg2) {
62577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62578     return ;
62579   }
62580   {
62581     try {
62582       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62583     } catch (std::out_of_range& e) {
62584       {
62585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62586       };
62587     } catch (std::exception& e) {
62588       {
62589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62590       };
62591     } catch (Dali::DaliException e) {
62592       {
62593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62594       };
62595     } catch (...) {
62596       {
62597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62598       };
62599     }
62600   }
62601
62602 }
62603
62604
62605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62607   Dali::TapGesture *arg2 = 0 ;
62608
62609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62610   arg2 = (Dali::TapGesture *)jarg2;
62611   if (!arg2) {
62612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62613     return ;
62614   }
62615   {
62616     try {
62617       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62618     } catch (std::out_of_range& e) {
62619       {
62620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62621       };
62622     } catch (std::exception& e) {
62623       {
62624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62625       };
62626     } catch (Dali::DaliException e) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62633       };
62634     }
62635   }
62636
62637 }
62638
62639
62640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62642   Dali::TapGesture *arg2 = 0 ;
62643
62644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62645   arg2 = (Dali::TapGesture *)jarg2;
62646   if (!arg2) {
62647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62648     return ;
62649   }
62650   {
62651     try {
62652       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62653     } catch (std::out_of_range& e) {
62654       {
62655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62656       };
62657     } catch (std::exception& e) {
62658       {
62659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62660       };
62661     } catch (Dali::DaliException e) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62664       };
62665     } catch (...) {
62666       {
62667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62668       };
62669     }
62670   }
62671
62672 }
62673
62674
62675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62677   Dali::LongPressGesture *arg2 = 0 ;
62678
62679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62680   arg2 = (Dali::LongPressGesture *)jarg2;
62681   if (!arg2) {
62682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62683     return ;
62684   }
62685   {
62686     try {
62687       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62695       };
62696     } catch (Dali::DaliException e) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62699       };
62700     } catch (...) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62703       };
62704     }
62705   }
62706
62707 }
62708
62709
62710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62712   Dali::LongPressGesture *arg2 = 0 ;
62713
62714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62715   arg2 = (Dali::LongPressGesture *)jarg2;
62716   if (!arg2) {
62717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62718     return ;
62719   }
62720   {
62721     try {
62722       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62723     } catch (std::out_of_range& e) {
62724       {
62725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62726       };
62727     } catch (std::exception& e) {
62728       {
62729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62730       };
62731     } catch (Dali::DaliException e) {
62732       {
62733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62734       };
62735     } catch (...) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62738       };
62739     }
62740   }
62741
62742 }
62743
62744
62745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62746   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62747   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62748   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62749
62750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62751   arg2 = (Dali::SlotObserver *)jarg2;
62752   arg3 = (Dali::CallbackBase *)jarg3;
62753   {
62754     try {
62755       (arg1)->SignalConnected(arg2,arg3);
62756     } catch (std::out_of_range& e) {
62757       {
62758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62759       };
62760     } catch (std::exception& e) {
62761       {
62762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62763       };
62764     } catch (Dali::DaliException e) {
62765       {
62766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62767       };
62768     } catch (...) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62771       };
62772     }
62773   }
62774
62775 }
62776
62777
62778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62780   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62781   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62782
62783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62784   arg2 = (Dali::SlotObserver *)jarg2;
62785   arg3 = (Dali::CallbackBase *)jarg3;
62786   {
62787     try {
62788       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62789     } catch (std::out_of_range& e) {
62790       {
62791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62792       };
62793     } catch (std::exception& e) {
62794       {
62795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62796       };
62797     } catch (Dali::DaliException e) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62800       };
62801     } catch (...) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62804       };
62805     }
62806   }
62807
62808 }
62809
62810
62811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62813   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62814   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62815
62816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62817   arg2 = (Dali::SlotObserver *)jarg2;
62818   arg3 = (Dali::CallbackBase *)jarg3;
62819   {
62820     try {
62821       (arg1)->SignalDisconnected(arg2,arg3);
62822     } catch (std::out_of_range& e) {
62823       {
62824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62825       };
62826     } catch (std::exception& e) {
62827       {
62828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62829       };
62830     } catch (Dali::DaliException e) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62833       };
62834     } catch (...) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62837       };
62838     }
62839   }
62840
62841 }
62842
62843
62844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62846   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62847   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62848
62849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62850   arg2 = (Dali::SlotObserver *)jarg2;
62851   arg3 = (Dali::CallbackBase *)jarg3;
62852   {
62853     try {
62854       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62855     } catch (std::out_of_range& e) {
62856       {
62857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62858       };
62859     } catch (std::exception& e) {
62860       {
62861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62862       };
62863     } catch (Dali::DaliException e) {
62864       {
62865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62866       };
62867     } catch (...) {
62868       {
62869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62870       };
62871     }
62872   }
62873
62874 }
62875
62876 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) {
62877   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62878   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62879   if (director) {
62880     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);
62881   }
62882 }
62883
62884
62885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62886   void * jresult ;
62887   Dali::Toolkit::Control *arg1 = 0 ;
62888   Dali::Toolkit::Internal::Control *result = 0 ;
62889
62890   arg1 = (Dali::Toolkit::Control *)jarg1;
62891   if (!arg1) {
62892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62893     return 0;
62894   }
62895   {
62896     try {
62897       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62898     } catch (std::out_of_range& e) {
62899       {
62900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62901       };
62902     } catch (std::exception& e) {
62903       {
62904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62905       };
62906     } catch (Dali::DaliException e) {
62907       {
62908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62909       };
62910     } catch (...) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62913       };
62914     }
62915   }
62916
62917   jresult = (void *)result;
62918   return jresult;
62919 }
62920
62921
62922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62923   int jresult ;
62924   int result;
62925
62926   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62927   jresult = (int)result;
62928   return jresult;
62929 }
62930
62931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62932   int jresult ;
62933   int result;
62934
62935   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62936   jresult = (int)result;
62937   return jresult;
62938 }
62939
62940
62941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62942   int jresult ;
62943   int result;
62944
62945   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62946   jresult = (int)result;
62947   return jresult;
62948 }
62949
62950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62951   int jresult ;
62952   int result;
62953
62954   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62955   jresult = (int)result;
62956   return jresult;
62957 }
62958
62959
62960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62961   int jresult ;
62962   int result;
62963
62964   result = (int)Dali::Toolkit::Control::Property::PADDING;
62965   jresult = (int)result;
62966   return jresult;
62967 }
62968
62969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62970   int jresult ;
62971   int result;
62972
62973   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62974   jresult = (int)result;
62975   return jresult;
62976 }
62977
62978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62979   void * jresult ;
62980   Dali::Toolkit::Control::Property *result = 0 ;
62981
62982   {
62983     try {
62984       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62985     } catch (std::out_of_range& e) {
62986       {
62987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62988       };
62989     } catch (std::exception& e) {
62990       {
62991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62992       };
62993     } catch (Dali::DaliException e) {
62994       {
62995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62996       };
62997     } catch (...) {
62998       {
62999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63000       };
63001     }
63002   }
63003
63004   jresult = (void *)result;
63005   return jresult;
63006 }
63007
63008
63009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63010   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63011
63012   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63013   {
63014     try {
63015       delete arg1;
63016     } catch (std::out_of_range& e) {
63017       {
63018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63019       };
63020     } catch (std::exception& e) {
63021       {
63022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63023       };
63024     } catch (Dali::DaliException e) {
63025       {
63026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63027       };
63028     } catch (...) {
63029       {
63030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63031       };
63032     }
63033   }
63034
63035 }
63036
63037
63038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63039   void * jresult ;
63040   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63041
63042   {
63043     try {
63044       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63045     } catch (std::out_of_range& e) {
63046       {
63047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63048       };
63049     } catch (std::exception& e) {
63050       {
63051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63052       };
63053     } catch (Dali::DaliException e) {
63054       {
63055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63056       };
63057     } catch (...) {
63058       {
63059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63060       };
63061     }
63062   }
63063
63064   jresult = (void *)result;
63065   return jresult;
63066 }
63067
63068
63069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63070   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63071
63072   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63073   {
63074     try {
63075       delete arg1;
63076     } catch (std::out_of_range& e) {
63077       {
63078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63079       };
63080     } catch (std::exception& e) {
63081       {
63082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63083       };
63084     } catch (Dali::DaliException e) {
63085       {
63086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63087       };
63088     } catch (...) {
63089       {
63090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63091       };
63092     }
63093   }
63094
63095 }
63096
63097
63098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63099   void * jresult ;
63100   Dali::Toolkit::Control result;
63101
63102   {
63103     try {
63104       result = Dali::Toolkit::Control::New();
63105     } catch (std::out_of_range& e) {
63106       {
63107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (std::exception& e) {
63110       {
63111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (Dali::DaliException e) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63120       };
63121     }
63122   }
63123
63124   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63125   return jresult;
63126 }
63127
63128
63129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63130   void * jresult ;
63131   Dali::Toolkit::Control *result = 0 ;
63132
63133   {
63134     try {
63135       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63143       };
63144     } catch (Dali::DaliException e) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63147       };
63148     } catch (...) {
63149       {
63150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63151       };
63152     }
63153   }
63154
63155   jresult = (void *)result;
63156   return jresult;
63157 }
63158
63159
63160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63161   void * jresult ;
63162   Dali::Toolkit::Control *arg1 = 0 ;
63163   Dali::Toolkit::Control *result = 0 ;
63164
63165   arg1 = (Dali::Toolkit::Control *)jarg1;
63166   if (!arg1) {
63167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63168     return 0;
63169   }
63170   {
63171     try {
63172       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63173     } catch (std::out_of_range& e) {
63174       {
63175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63176       };
63177     } catch (std::exception& e) {
63178       {
63179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63180       };
63181     } catch (Dali::DaliException e) {
63182       {
63183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63184       };
63185     } catch (...) {
63186       {
63187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63188       };
63189     }
63190   }
63191
63192   jresult = (void *)result;
63193   return jresult;
63194 }
63195
63196
63197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63198   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63199
63200   arg1 = (Dali::Toolkit::Control *)jarg1;
63201   {
63202     try {
63203       delete arg1;
63204     } catch (std::out_of_range& e) {
63205       {
63206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63207       };
63208     } catch (std::exception& e) {
63209       {
63210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (Dali::DaliException e) {
63213       {
63214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63215       };
63216     } catch (...) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63219       };
63220     }
63221   }
63222
63223 }
63224
63225
63226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63227   void * jresult ;
63228   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63229   Dali::Toolkit::Control *arg2 = 0 ;
63230   Dali::Toolkit::Control *result = 0 ;
63231
63232   arg1 = (Dali::Toolkit::Control *)jarg1;
63233   arg2 = (Dali::Toolkit::Control *)jarg2;
63234   if (!arg2) {
63235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63236     return 0;
63237   }
63238   {
63239     try {
63240       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63241     } catch (std::out_of_range& e) {
63242       {
63243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63244       };
63245     } catch (std::exception& e) {
63246       {
63247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63248       };
63249     } catch (Dali::DaliException e) {
63250       {
63251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63252       };
63253     } catch (...) {
63254       {
63255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63256       };
63257     }
63258   }
63259
63260   jresult = (void *)result;
63261   return jresult;
63262 }
63263
63264
63265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63266   void * jresult ;
63267   Dali::BaseHandle arg1 ;
63268   Dali::BaseHandle *argp1 ;
63269   Dali::Toolkit::Control result;
63270
63271   argp1 = (Dali::BaseHandle *)jarg1;
63272   if (!argp1) {
63273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63274     return 0;
63275   }
63276   arg1 = *argp1;
63277   {
63278     try {
63279       result = Dali::Toolkit::Control::DownCast(arg1);
63280     } catch (std::out_of_range& e) {
63281       {
63282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63283       };
63284     } catch (std::exception& e) {
63285       {
63286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63287       };
63288     } catch (Dali::DaliException e) {
63289       {
63290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63291       };
63292     } catch (...) {
63293       {
63294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63295       };
63296     }
63297   }
63298
63299   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63300   return jresult;
63301 }
63302
63303
63304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63305   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63306
63307   arg1 = (Dali::Toolkit::Control *)jarg1;
63308   {
63309     try {
63310       (arg1)->SetKeyInputFocus();
63311     } catch (std::out_of_range& e) {
63312       {
63313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63314       };
63315     } catch (std::exception& e) {
63316       {
63317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63318       };
63319     } catch (Dali::DaliException e) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63322       };
63323     } catch (...) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63326       };
63327     }
63328   }
63329
63330 }
63331
63332
63333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63334   unsigned int jresult ;
63335   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63336   bool result;
63337
63338   arg1 = (Dali::Toolkit::Control *)jarg1;
63339   {
63340     try {
63341       result = (bool)(arg1)->HasKeyInputFocus();
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63367   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63368
63369   arg1 = (Dali::Toolkit::Control *)jarg1;
63370   {
63371     try {
63372       (arg1)->ClearKeyInputFocus();
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63380       };
63381     } catch (Dali::DaliException e) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63384       };
63385     } catch (...) {
63386       {
63387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63388       };
63389     }
63390   }
63391
63392 }
63393
63394
63395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63396   void * jresult ;
63397   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63398   Dali::PinchGestureDetector result;
63399
63400   arg1 = (Dali::Toolkit::Control *)jarg1;
63401   {
63402     try {
63403       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63419       };
63420     }
63421   }
63422
63423   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63429   void * jresult ;
63430   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63431   Dali::PanGestureDetector result;
63432
63433   arg1 = (Dali::Toolkit::Control *)jarg1;
63434   {
63435     try {
63436       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63437     } catch (std::out_of_range& e) {
63438       {
63439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63440       };
63441     } catch (std::exception& e) {
63442       {
63443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63444       };
63445     } catch (Dali::DaliException e) {
63446       {
63447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63448       };
63449     } catch (...) {
63450       {
63451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63452       };
63453     }
63454   }
63455
63456   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63457   return jresult;
63458 }
63459
63460
63461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63462   void * jresult ;
63463   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63464   Dali::TapGestureDetector result;
63465
63466   arg1 = (Dali::Toolkit::Control *)jarg1;
63467   {
63468     try {
63469       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63485       };
63486     }
63487   }
63488
63489   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63490   return jresult;
63491 }
63492
63493
63494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63495   void * jresult ;
63496   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63497   Dali::LongPressGestureDetector result;
63498
63499   arg1 = (Dali::Toolkit::Control *)jarg1;
63500   {
63501     try {
63502       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63503     } catch (std::out_of_range& e) {
63504       {
63505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63506       };
63507     } catch (std::exception& e) {
63508       {
63509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63510       };
63511     } catch (Dali::DaliException e) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63514       };
63515     } catch (...) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63518       };
63519     }
63520   }
63521
63522   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63523   return jresult;
63524 }
63525
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63528   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63529   std::string *arg2 = 0 ;
63530
63531   arg1 = (Dali::Toolkit::Control *)jarg1;
63532   if (!jarg2) {
63533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63534     return ;
63535   }
63536   std::string arg2_str(jarg2);
63537   arg2 = &arg2_str;
63538   {
63539     try {
63540       (arg1)->SetStyleName((std::string const &)*arg2);
63541     } catch (std::out_of_range& e) {
63542       {
63543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63544       };
63545     } catch (std::exception& e) {
63546       {
63547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63548       };
63549     } catch (Dali::DaliException e) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63552       };
63553     } catch (...) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63556       };
63557     }
63558   }
63559
63560
63561   //argout typemap for const std::string&
63562
63563 }
63564
63565
63566 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63567   char * jresult ;
63568   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63569   std::string *result = 0 ;
63570
63571   arg1 = (Dali::Toolkit::Control *)jarg1;
63572   {
63573     try {
63574       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63590       };
63591     }
63592   }
63593
63594   jresult = SWIG_csharp_string_callback(result->c_str());
63595   return jresult;
63596 }
63597
63598
63599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63600   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63601   Dali::Vector4 *arg2 = 0 ;
63602
63603   arg1 = (Dali::Toolkit::Control *)jarg1;
63604   arg2 = (Dali::Vector4 *)jarg2;
63605   if (!arg2) {
63606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63607     return ;
63608   }
63609   {
63610     try {
63611       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63612     } catch (std::out_of_range& e) {
63613       {
63614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63615       };
63616     } catch (std::exception& e) {
63617       {
63618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63619       };
63620     } catch (Dali::DaliException e) {
63621       {
63622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63623       };
63624     } catch (...) {
63625       {
63626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63627       };
63628     }
63629   }
63630
63631 }
63632
63633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63634   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63635
63636   arg1 = (Dali::Toolkit::Control *)jarg1;
63637   {
63638     try {
63639       (arg1)->ClearBackground();
63640     } catch (std::out_of_range& e) {
63641       {
63642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63643       };
63644     } catch (std::exception& e) {
63645       {
63646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63647       };
63648     } catch (Dali::DaliException e) {
63649       {
63650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63651       };
63652     } catch (...) {
63653       {
63654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63655       };
63656     }
63657   }
63658
63659 }
63660
63661
63662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63663   void * jresult ;
63664   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63665   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63666
63667   arg1 = (Dali::Toolkit::Control *)jarg1;
63668   {
63669     try {
63670       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63671     } catch (std::out_of_range& e) {
63672       {
63673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63674       };
63675     } catch (std::exception& e) {
63676       {
63677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63678       };
63679     } catch (Dali::DaliException e) {
63680       {
63681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63682       };
63683     } catch (...) {
63684       {
63685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63686       };
63687     }
63688   }
63689
63690   jresult = (void *)result;
63691   return jresult;
63692 }
63693
63694
63695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63696   void * jresult ;
63697   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63698   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63699
63700   arg1 = (Dali::Toolkit::Control *)jarg1;
63701   {
63702     try {
63703       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63704     } catch (std::out_of_range& e) {
63705       {
63706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63707       };
63708     } catch (std::exception& e) {
63709       {
63710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63711       };
63712     } catch (Dali::DaliException e) {
63713       {
63714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63715       };
63716     } catch (...) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63719       };
63720     }
63721   }
63722
63723   jresult = (void *)result;
63724   return jresult;
63725 }
63726
63727
63728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63729   void * jresult ;
63730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63731   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63732
63733   arg1 = (Dali::Toolkit::Control *)jarg1;
63734   {
63735     try {
63736       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63737     } catch (std::out_of_range& e) {
63738       {
63739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (std::exception& e) {
63742       {
63743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (Dali::DaliException e) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63752       };
63753     }
63754   }
63755
63756   jresult = (void *)result;
63757   return jresult;
63758 }
63759
63760
63761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63762   void * jresult ;
63763   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63764   Dali::Toolkit::Control *result = 0 ;
63765
63766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63767   if (!arg1) {
63768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63769     return 0;
63770   }
63771   {
63772     try {
63773       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63774     } catch (std::out_of_range& e) {
63775       {
63776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63777       };
63778     } catch (std::exception& e) {
63779       {
63780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63781       };
63782     } catch (Dali::DaliException e) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63789       };
63790     }
63791   }
63792
63793   jresult = (void *)result;
63794   return jresult;
63795 }
63796
63797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63798 {
63799   int jresult;
63800   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63801   arg1 = (Dali::Toolkit::Control *)jarg1;
63802
63803   if (!arg1) {
63804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63805     return 0;
63806   }
63807
63808   Dali::Property::Index arg2 = 0 ;
63809   arg2 = (Dali::Property::Index)jarg2;
63810
63811   Toolkit::Visual::ResourceStatus result;
63812   {
63813     try {
63814       result = arg1->GetVisualResourceStatus(arg2);
63815     } catch (std::out_of_range& e) {
63816       {
63817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63818       };
63819     } catch (std::exception& e) {
63820       {
63821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63822       };
63823     } catch (...) {
63824       {
63825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63826       };
63827     }
63828   }
63829   jresult = (int)(result);
63830   return jresult;
63831 }
63832
63833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63834 {
63835   void * jresult;
63836   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63837   arg1 = (Dali::Toolkit::Control *)jarg1;
63838
63839   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63840
63841   Dali::Toolkit::TransitionData *arg2 = 0 ;
63842   Dali::Animation result;
63843
63844   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63845   if (!arg2) {
63846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63847     return 0;
63848   }
63849   {
63850     try {
63851       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63852     } catch (std::out_of_range& e) {
63853       {
63854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63855       };
63856     } catch (std::exception& e) {
63857       {
63858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63859       };
63860     } catch (Dali::DaliException e) {
63861       {
63862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63863       };
63864     } catch (...) {
63865       {
63866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63867       };
63868     }
63869   }
63870
63871   jresult = new Dali::Animation((const Dali::Animation &)result);
63872   return jresult;
63873 }
63874
63875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63876 {
63877   Dali::Toolkit::Control arg1;
63878   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63879
63880   if (!argp1) {
63881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63882   }
63883   arg1 = *argp1;
63884
63885   Dali::Property::Index arg2 = 0 ;
63886   arg2 = (Dali::Property::Index)jarg2;
63887
63888   Dali::Property::Index arg3 = 0 ;
63889   arg3 = (Dali::Property::Index)jarg3;
63890
63891   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63892
63893   {
63894     try {
63895       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63896     } catch (std::out_of_range& e) {
63897       {
63898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63899       };
63900     } catch (std::exception& e) {
63901       {
63902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63903       };
63904     } catch (...) {
63905       {
63906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63907       };
63908     }
63909   }
63910
63911
63912 }
63913
63914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63915   void * jresult ;
63916   Dali::Toolkit::Control *arg1 = 0 ;
63917   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63918
63919   arg1 = (Dali::Toolkit::Control *)jarg1;
63920   if (!arg1) {
63921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63922     return 0;
63923   }
63924   {
63925     try {
63926       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63927     } catch (std::out_of_range& e) {
63928       {
63929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63930       };
63931     } catch (std::exception& e) {
63932       {
63933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63934       };
63935     } catch (Dali::DaliException e) {
63936       {
63937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63938       };
63939     } catch (...) {
63940       {
63941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63942       };
63943     }
63944   }
63945
63946   jresult = (void *)result;
63947   return jresult;
63948 }
63949
63950
63951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63952   unsigned int jresult ;
63953   Dali::Toolkit::Control *arg1 = 0 ;
63954   bool result;
63955
63956   arg1 = (Dali::Toolkit::Control *)jarg1;
63957   if (!arg1) {
63958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63959     return 0;
63960   }
63961   {
63962     try {
63963       result = (bool)arg1->IsResourceReady();
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63979       };
63980     }
63981   }
63982
63983   jresult = result;
63984   return jresult;
63985 }
63986
63987
63988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63989   void * jresult ;
63990   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63991
63992   {
63993     try {
63994       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64002       };
64003     } catch (Dali::DaliException e) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64006       };
64007     } catch (...) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64010       };
64011     }
64012   }
64013
64014   jresult = (void *)result;
64015   return jresult;
64016 }
64017
64018
64019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64020   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64021
64022   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64023   {
64024     try {
64025       delete arg1;
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64033       };
64034     } catch (Dali::DaliException e) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64037       };
64038     } catch (...) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64041       };
64042     }
64043   }
64044
64045 }
64046
64047
64048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64049   void * jresult ;
64050   Dali::Toolkit::KeyInputFocusManager result;
64051
64052   {
64053     try {
64054       result = Dali::Toolkit::KeyInputFocusManager::Get();
64055     } catch (std::out_of_range& e) {
64056       {
64057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64058       };
64059     } catch (std::exception& e) {
64060       {
64061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (Dali::DaliException e) {
64064       {
64065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64066       };
64067     } catch (...) {
64068       {
64069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64070       };
64071     }
64072   }
64073
64074   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64075   return jresult;
64076 }
64077
64078
64079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64080   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64081   Dali::Toolkit::Control arg2 ;
64082   Dali::Toolkit::Control *argp2 ;
64083
64084   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64085   argp2 = (Dali::Toolkit::Control *)jarg2;
64086   if (!argp2) {
64087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64088     return ;
64089   }
64090   arg2 = *argp2;
64091   {
64092     try {
64093       (arg1)->SetFocus(arg2);
64094     } catch (std::out_of_range& e) {
64095       {
64096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64097       };
64098     } catch (std::exception& e) {
64099       {
64100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64101       };
64102     } catch (Dali::DaliException e) {
64103       {
64104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64105       };
64106     } catch (...) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64109       };
64110     }
64111   }
64112
64113 }
64114
64115
64116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64117   void * jresult ;
64118   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64119   Dali::Toolkit::Control result;
64120
64121   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64122   {
64123     try {
64124       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64125     } catch (std::out_of_range& e) {
64126       {
64127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64128       };
64129     } catch (std::exception& e) {
64130       {
64131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64132       };
64133     } catch (Dali::DaliException e) {
64134       {
64135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64136       };
64137     } catch (...) {
64138       {
64139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64140       };
64141     }
64142   }
64143
64144   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64145   return jresult;
64146 }
64147
64148
64149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64150   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64151   Dali::Toolkit::Control arg2 ;
64152   Dali::Toolkit::Control *argp2 ;
64153
64154   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64155   argp2 = (Dali::Toolkit::Control *)jarg2;
64156   if (!argp2) {
64157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64158     return ;
64159   }
64160   arg2 = *argp2;
64161   {
64162     try {
64163       (arg1)->RemoveFocus(arg2);
64164     } catch (std::out_of_range& e) {
64165       {
64166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64167       };
64168     } catch (std::exception& e) {
64169       {
64170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64171       };
64172     } catch (Dali::DaliException e) {
64173       {
64174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64175       };
64176     } catch (...) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64179       };
64180     }
64181   }
64182
64183 }
64184
64185
64186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64187   void * jresult ;
64188   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64189   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64190
64191   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64192   {
64193     try {
64194       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64195     } catch (std::out_of_range& e) {
64196       {
64197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64198       };
64199     } catch (std::exception& e) {
64200       {
64201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (Dali::DaliException e) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64206       };
64207     } catch (...) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64210       };
64211     }
64212   }
64213
64214   jresult = (void *)result;
64215   return jresult;
64216 }
64217
64218
64219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64220   void * jresult ;
64221   Dali::Toolkit::Alignment::Padding *result = 0 ;
64222
64223   {
64224     try {
64225       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64226     } catch (std::out_of_range& e) {
64227       {
64228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64229       };
64230     } catch (std::exception& e) {
64231       {
64232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64233       };
64234     } catch (Dali::DaliException e) {
64235       {
64236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64237       };
64238     } catch (...) {
64239       {
64240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64241       };
64242     }
64243   }
64244
64245   jresult = (void *)result;
64246   return jresult;
64247 }
64248
64249
64250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64251   void * jresult ;
64252   float arg1 ;
64253   float arg2 ;
64254   float arg3 ;
64255   float arg4 ;
64256   Dali::Toolkit::Alignment::Padding *result = 0 ;
64257
64258   arg1 = (float)jarg1;
64259   arg2 = (float)jarg2;
64260   arg3 = (float)jarg3;
64261   arg4 = (float)jarg4;
64262   {
64263     try {
64264       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64272       };
64273     } catch (Dali::DaliException e) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64280       };
64281     }
64282   }
64283
64284   jresult = (void *)result;
64285   return jresult;
64286 }
64287
64288
64289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64290   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64291   float arg2 ;
64292
64293   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64294   arg2 = (float)jarg2;
64295   if (arg1) (arg1)->left = arg2;
64296 }
64297
64298
64299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64300   float jresult ;
64301   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64302   float result;
64303
64304   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64305   result = (float) ((arg1)->left);
64306   jresult = result;
64307   return jresult;
64308 }
64309
64310
64311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64312   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64313   float arg2 ;
64314
64315   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64316   arg2 = (float)jarg2;
64317   if (arg1) (arg1)->right = arg2;
64318 }
64319
64320
64321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64322   float jresult ;
64323   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64324   float result;
64325
64326   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64327   result = (float) ((arg1)->right);
64328   jresult = result;
64329   return jresult;
64330 }
64331
64332
64333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64334   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64335   float arg2 ;
64336
64337   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64338   arg2 = (float)jarg2;
64339   if (arg1) (arg1)->top = arg2;
64340 }
64341
64342
64343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64344   float jresult ;
64345   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64346   float result;
64347
64348   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64349   result = (float) ((arg1)->top);
64350   jresult = result;
64351   return jresult;
64352 }
64353
64354
64355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64356   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64357   float arg2 ;
64358
64359   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64360   arg2 = (float)jarg2;
64361   if (arg1) (arg1)->bottom = arg2;
64362 }
64363
64364
64365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64366   float jresult ;
64367   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64368   float result;
64369
64370   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64371   result = (float) ((arg1)->bottom);
64372   jresult = result;
64373   return jresult;
64374 }
64375
64376
64377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64378   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64379
64380   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64381   {
64382     try {
64383       delete arg1;
64384     } catch (std::out_of_range& e) {
64385       {
64386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64387       };
64388     } catch (std::exception& e) {
64389       {
64390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64391       };
64392     } catch (Dali::DaliException e) {
64393       {
64394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64395       };
64396     } catch (...) {
64397       {
64398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64399       };
64400     }
64401   }
64402
64403 }
64404
64405
64406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64407   void * jresult ;
64408   Dali::Toolkit::Alignment *result = 0 ;
64409
64410   {
64411     try {
64412       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64413     } catch (std::out_of_range& e) {
64414       {
64415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64416       };
64417     } catch (std::exception& e) {
64418       {
64419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64420       };
64421     } catch (Dali::DaliException e) {
64422       {
64423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64424       };
64425     } catch (...) {
64426       {
64427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64428       };
64429     }
64430   }
64431
64432   jresult = (void *)result;
64433   return jresult;
64434 }
64435
64436
64437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64438   void * jresult ;
64439   Dali::Toolkit::Alignment::Type arg1 ;
64440   Dali::Toolkit::Alignment::Type arg2 ;
64441   Dali::Toolkit::Alignment result;
64442
64443   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64444   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64445   {
64446     try {
64447       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64448     } catch (std::out_of_range& e) {
64449       {
64450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64451       };
64452     } catch (std::exception& e) {
64453       {
64454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64455       };
64456     } catch (Dali::DaliException e) {
64457       {
64458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64459       };
64460     } catch (...) {
64461       {
64462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64463       };
64464     }
64465   }
64466
64467   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64468   return jresult;
64469 }
64470
64471
64472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64473   void * jresult ;
64474   Dali::Toolkit::Alignment::Type arg1 ;
64475   Dali::Toolkit::Alignment result;
64476
64477   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64478   {
64479     try {
64480       result = Dali::Toolkit::Alignment::New(arg1);
64481     } catch (std::out_of_range& e) {
64482       {
64483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (std::exception& e) {
64486       {
64487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64488       };
64489     } catch (Dali::DaliException e) {
64490       {
64491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64492       };
64493     } catch (...) {
64494       {
64495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64496       };
64497     }
64498   }
64499
64500   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64501   return jresult;
64502 }
64503
64504
64505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64506   void * jresult ;
64507   Dali::Toolkit::Alignment result;
64508
64509   {
64510     try {
64511       result = Dali::Toolkit::Alignment::New();
64512     } catch (std::out_of_range& e) {
64513       {
64514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64515       };
64516     } catch (std::exception& e) {
64517       {
64518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64519       };
64520     } catch (Dali::DaliException e) {
64521       {
64522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64523       };
64524     } catch (...) {
64525       {
64526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64527       };
64528     }
64529   }
64530
64531   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64532   return jresult;
64533 }
64534
64535
64536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64537   void * jresult ;
64538   Dali::Toolkit::Alignment *arg1 = 0 ;
64539   Dali::Toolkit::Alignment *result = 0 ;
64540
64541   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64542   if (!arg1) {
64543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64544     return 0;
64545   }
64546   {
64547     try {
64548       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64549     } catch (std::out_of_range& e) {
64550       {
64551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64552       };
64553     } catch (std::exception& e) {
64554       {
64555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64556       };
64557     } catch (Dali::DaliException e) {
64558       {
64559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64560       };
64561     } catch (...) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64564       };
64565     }
64566   }
64567
64568   jresult = (void *)result;
64569   return jresult;
64570 }
64571
64572
64573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64574   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64575
64576   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64577   {
64578     try {
64579       delete arg1;
64580     } catch (std::out_of_range& e) {
64581       {
64582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64583       };
64584     } catch (std::exception& e) {
64585       {
64586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64587       };
64588     } catch (Dali::DaliException e) {
64589       {
64590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64591       };
64592     } catch (...) {
64593       {
64594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64595       };
64596     }
64597   }
64598
64599 }
64600
64601
64602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64603   void * jresult ;
64604   Dali::BaseHandle arg1 ;
64605   Dali::BaseHandle *argp1 ;
64606   Dali::Toolkit::Alignment result;
64607
64608   argp1 = (Dali::BaseHandle *)jarg1;
64609   if (!argp1) {
64610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64611     return 0;
64612   }
64613   arg1 = *argp1;
64614   {
64615     try {
64616       result = Dali::Toolkit::Alignment::DownCast(arg1);
64617     } catch (std::out_of_range& e) {
64618       {
64619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64620       };
64621     } catch (std::exception& e) {
64622       {
64623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64624       };
64625     } catch (Dali::DaliException e) {
64626       {
64627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64628       };
64629     } catch (...) {
64630       {
64631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64632       };
64633     }
64634   }
64635
64636   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64637   return jresult;
64638 }
64639
64640
64641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64642   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64643   Dali::Toolkit::Alignment::Type arg2 ;
64644
64645   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64646   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64647   {
64648     try {
64649       (arg1)->SetAlignmentType(arg2);
64650     } catch (std::out_of_range& e) {
64651       {
64652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64653       };
64654     } catch (std::exception& e) {
64655       {
64656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64657       };
64658     } catch (Dali::DaliException e) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64661       };
64662     } catch (...) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64665       };
64666     }
64667   }
64668
64669 }
64670
64671
64672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64673   int jresult ;
64674   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64675   Dali::Toolkit::Alignment::Type result;
64676
64677   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64678   {
64679     try {
64680       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64681     } catch (std::out_of_range& e) {
64682       {
64683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (std::exception& e) {
64686       {
64687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64688       };
64689     } catch (Dali::DaliException e) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64692       };
64693     } catch (...) {
64694       {
64695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64696       };
64697     }
64698   }
64699
64700   jresult = (int)result;
64701   return jresult;
64702 }
64703
64704
64705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64706   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64707   Dali::Toolkit::Alignment::Scaling arg2 ;
64708
64709   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64710   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64711   {
64712     try {
64713       (arg1)->SetScaling(arg2);
64714     } catch (std::out_of_range& e) {
64715       {
64716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64717       };
64718     } catch (std::exception& e) {
64719       {
64720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64721       };
64722     } catch (Dali::DaliException e) {
64723       {
64724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64725       };
64726     } catch (...) {
64727       {
64728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64729       };
64730     }
64731   }
64732
64733 }
64734
64735
64736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64737   int jresult ;
64738   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64739   Dali::Toolkit::Alignment::Scaling result;
64740
64741   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64742   {
64743     try {
64744       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64745     } catch (std::out_of_range& e) {
64746       {
64747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64748       };
64749     } catch (std::exception& e) {
64750       {
64751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64752       };
64753     } catch (Dali::DaliException e) {
64754       {
64755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64756       };
64757     } catch (...) {
64758       {
64759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64760       };
64761     }
64762   }
64763
64764   jresult = (int)result;
64765   return jresult;
64766 }
64767
64768
64769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64770   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64771   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64772
64773   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64774   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64775   if (!arg2) {
64776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64777     return ;
64778   }
64779   {
64780     try {
64781       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64782     } catch (std::out_of_range& e) {
64783       {
64784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64785       };
64786     } catch (std::exception& e) {
64787       {
64788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64789       };
64790     } catch (Dali::DaliException e) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64793       };
64794     } catch (...) {
64795       {
64796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64797       };
64798     }
64799   }
64800
64801 }
64802
64803
64804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64805   void * jresult ;
64806   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64807   Dali::Toolkit::Alignment::Padding *result = 0 ;
64808
64809   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64810   {
64811     try {
64812       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (Dali::DaliException e) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64824       };
64825     } catch (...) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64828       };
64829     }
64830   }
64831
64832   jresult = (void *)result;
64833   return jresult;
64834 }
64835
64836
64837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64838   void * jresult ;
64839   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64840   Dali::Toolkit::Alignment *arg2 = 0 ;
64841   Dali::Toolkit::Alignment *result = 0 ;
64842
64843   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64844   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64845   if (!arg2) {
64846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64847     return 0;
64848   }
64849   {
64850     try {
64851       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64852     } catch (std::out_of_range& e) {
64853       {
64854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64855       };
64856     } catch (std::exception& e) {
64857       {
64858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64859       };
64860     } catch (Dali::DaliException e) {
64861       {
64862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64863       };
64864     } catch (...) {
64865       {
64866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64867       };
64868     }
64869   }
64870
64871   jresult = (void *)result;
64872   return jresult;
64873 }
64874
64875
64876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64877   int jresult ;
64878   int result;
64879
64880   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64881   jresult = (int)result;
64882   return jresult;
64883 }
64884
64885
64886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64887   int jresult ;
64888   int result;
64889
64890   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64891   jresult = (int)result;
64892   return jresult;
64893 }
64894
64895
64896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64897   int jresult ;
64898   int result;
64899
64900   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64901   jresult = (int)result;
64902   return jresult;
64903 }
64904
64905
64906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64907   int jresult ;
64908   int result;
64909
64910   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64911   jresult = (int)result;
64912   return jresult;
64913 }
64914
64915
64916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64917   int jresult ;
64918   int result;
64919
64920   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64921   jresult = (int)result;
64922   return jresult;
64923 }
64924
64925
64926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64927   int jresult ;
64928   int result;
64929
64930   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64931   jresult = (int)result;
64932   return jresult;
64933 }
64934
64935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64936   int jresult ;
64937   int result;
64938
64939   result = (int)Dali::Toolkit::Button::Property::LABEL;
64940   jresult = (int)result;
64941   return jresult;
64942 }
64943
64944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64945   void * jresult ;
64946   Dali::Toolkit::Button::Property *result = 0 ;
64947
64948   {
64949     try {
64950       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64951     } catch (std::out_of_range& e) {
64952       {
64953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64954       };
64955     } catch (std::exception& e) {
64956       {
64957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (Dali::DaliException e) {
64960       {
64961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64962       };
64963     } catch (...) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64966       };
64967     }
64968   }
64969
64970   jresult = (void *)result;
64971   return jresult;
64972 }
64973
64974
64975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64976   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64977
64978   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64979   {
64980     try {
64981       delete arg1;
64982     } catch (std::out_of_range& e) {
64983       {
64984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64985       };
64986     } catch (std::exception& e) {
64987       {
64988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64989       };
64990     } catch (Dali::DaliException e) {
64991       {
64992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64993       };
64994     } catch (...) {
64995       {
64996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64997       };
64998     }
64999   }
65000
65001 }
65002
65003
65004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65005   void * jresult ;
65006   Dali::Toolkit::Button *result = 0 ;
65007
65008   {
65009     try {
65010       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65011     } catch (std::out_of_range& e) {
65012       {
65013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (std::exception& e) {
65016       {
65017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65018       };
65019     } catch (Dali::DaliException e) {
65020       {
65021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65022       };
65023     } catch (...) {
65024       {
65025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65026       };
65027     }
65028   }
65029
65030   jresult = (void *)result;
65031   return jresult;
65032 }
65033
65034
65035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65036   void * jresult ;
65037   Dali::Toolkit::Button *arg1 = 0 ;
65038   Dali::Toolkit::Button *result = 0 ;
65039
65040   arg1 = (Dali::Toolkit::Button *)jarg1;
65041   if (!arg1) {
65042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65043     return 0;
65044   }
65045   {
65046     try {
65047       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65048     } catch (std::out_of_range& e) {
65049       {
65050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65051       };
65052     } catch (std::exception& e) {
65053       {
65054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65055       };
65056     } catch (Dali::DaliException e) {
65057       {
65058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65059       };
65060     } catch (...) {
65061       {
65062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65063       };
65064     }
65065   }
65066
65067   jresult = (void *)result;
65068   return jresult;
65069 }
65070
65071
65072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65073   void * jresult ;
65074   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65075   Dali::Toolkit::Button *arg2 = 0 ;
65076   Dali::Toolkit::Button *result = 0 ;
65077
65078   arg1 = (Dali::Toolkit::Button *)jarg1;
65079   arg2 = (Dali::Toolkit::Button *)jarg2;
65080   if (!arg2) {
65081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65082     return 0;
65083   }
65084   {
65085     try {
65086       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65087     } catch (std::out_of_range& e) {
65088       {
65089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65090       };
65091     } catch (std::exception& e) {
65092       {
65093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65094       };
65095     } catch (Dali::DaliException e) {
65096       {
65097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65098       };
65099     } catch (...) {
65100       {
65101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65102       };
65103     }
65104   }
65105
65106   jresult = (void *)result;
65107   return jresult;
65108 }
65109
65110
65111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65112   void * jresult ;
65113   Dali::BaseHandle arg1 ;
65114   Dali::BaseHandle *argp1 ;
65115   Dali::Toolkit::Button result;
65116
65117   argp1 = (Dali::BaseHandle *)jarg1;
65118   if (!argp1) {
65119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65120     return 0;
65121   }
65122   arg1 = *argp1;
65123   {
65124     try {
65125       result = Dali::Toolkit::Button::DownCast(arg1);
65126     } catch (std::out_of_range& e) {
65127       {
65128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (std::exception& e) {
65131       {
65132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65133       };
65134     } catch (Dali::DaliException e) {
65135       {
65136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65137       };
65138     } catch (...) {
65139       {
65140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65141       };
65142     }
65143   }
65144
65145   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65146   return jresult;
65147 }
65148
65149
65150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65151   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65152
65153   arg1 = (Dali::Toolkit::Button *)jarg1;
65154   {
65155     try {
65156       delete arg1;
65157     } catch (std::out_of_range& e) {
65158       {
65159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65160       };
65161     } catch (std::exception& e) {
65162       {
65163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65164       };
65165     } catch (Dali::DaliException e) {
65166       {
65167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65168       };
65169     } catch (...) {
65170       {
65171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65172       };
65173     }
65174   }
65175
65176 }
65177
65178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65179   void * jresult ;
65180   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65181   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65182
65183   arg1 = (Dali::Toolkit::Button *)jarg1;
65184   {
65185     try {
65186       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65187     } catch (std::out_of_range& e) {
65188       {
65189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65190       };
65191     } catch (std::exception& e) {
65192       {
65193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65194       };
65195     } catch (Dali::DaliException e) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65198       };
65199     } catch (...) {
65200       {
65201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65202       };
65203     }
65204   }
65205
65206   jresult = (void *)result;
65207   return jresult;
65208 }
65209
65210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65211   void * jresult ;
65212   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65213   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65214
65215   arg1 = (Dali::Toolkit::Button *)jarg1;
65216   {
65217     try {
65218       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65219     } catch (std::out_of_range& e) {
65220       {
65221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (std::exception& e) {
65224       {
65225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (Dali::DaliException e) {
65228       {
65229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65230       };
65231     } catch (...) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65234       };
65235     }
65236   }
65237
65238   jresult = (void *)result;
65239   return jresult;
65240 }
65241
65242
65243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65244   void * jresult ;
65245   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65246   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65247
65248   arg1 = (Dali::Toolkit::Button *)jarg1;
65249   {
65250     try {
65251       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65252     } catch (std::out_of_range& e) {
65253       {
65254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65255       };
65256     } catch (std::exception& e) {
65257       {
65258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (Dali::DaliException e) {
65261       {
65262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65263       };
65264     } catch (...) {
65265       {
65266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65267       };
65268     }
65269   }
65270
65271   jresult = (void *)result;
65272   return jresult;
65273 }
65274
65275
65276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65277   void * jresult ;
65278   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65279   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65280
65281   arg1 = (Dali::Toolkit::Button *)jarg1;
65282   {
65283     try {
65284       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65285     } catch (std::out_of_range& e) {
65286       {
65287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65288       };
65289     } catch (std::exception& e) {
65290       {
65291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65292       };
65293     } catch (Dali::DaliException e) {
65294       {
65295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65296       };
65297     } catch (...) {
65298       {
65299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65300       };
65301     }
65302   }
65303
65304   jresult = (void *)result;
65305   return jresult;
65306 }
65307
65308
65309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65310   void * jresult ;
65311   Dali::Toolkit::CheckBoxButton *result = 0 ;
65312
65313   {
65314     try {
65315       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65316     } catch (std::out_of_range& e) {
65317       {
65318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65319       };
65320     } catch (std::exception& e) {
65321       {
65322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65323       };
65324     } catch (Dali::DaliException e) {
65325       {
65326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65327       };
65328     } catch (...) {
65329       {
65330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65331       };
65332     }
65333   }
65334
65335   jresult = (void *)result;
65336   return jresult;
65337 }
65338
65339
65340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65341   void * jresult ;
65342   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65343   Dali::Toolkit::CheckBoxButton *result = 0 ;
65344
65345   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65346   if (!arg1) {
65347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65348     return 0;
65349   }
65350   {
65351     try {
65352       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65353     } catch (std::out_of_range& e) {
65354       {
65355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65356       };
65357     } catch (std::exception& e) {
65358       {
65359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65360       };
65361     } catch (Dali::DaliException e) {
65362       {
65363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65364       };
65365     } catch (...) {
65366       {
65367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65368       };
65369     }
65370   }
65371
65372   jresult = (void *)result;
65373   return jresult;
65374 }
65375
65376
65377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65378   void * jresult ;
65379   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65380   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65381   Dali::Toolkit::CheckBoxButton *result = 0 ;
65382
65383   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65384   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65385   if (!arg2) {
65386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65387     return 0;
65388   }
65389   {
65390     try {
65391       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65392     } catch (std::out_of_range& e) {
65393       {
65394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65395       };
65396     } catch (std::exception& e) {
65397       {
65398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65399       };
65400     } catch (Dali::DaliException e) {
65401       {
65402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65403       };
65404     } catch (...) {
65405       {
65406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65407       };
65408     }
65409   }
65410
65411   jresult = (void *)result;
65412   return jresult;
65413 }
65414
65415
65416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65417   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65418
65419   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65420   {
65421     try {
65422       delete arg1;
65423     } catch (std::out_of_range& e) {
65424       {
65425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65426       };
65427     } catch (std::exception& e) {
65428       {
65429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65430       };
65431     } catch (Dali::DaliException e) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65434       };
65435     } catch (...) {
65436       {
65437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65438       };
65439     }
65440   }
65441
65442 }
65443
65444
65445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65446   void * jresult ;
65447   Dali::Toolkit::CheckBoxButton result;
65448
65449   {
65450     try {
65451       result = Dali::Toolkit::CheckBoxButton::New();
65452     } catch (std::out_of_range& e) {
65453       {
65454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65455       };
65456     } catch (std::exception& e) {
65457       {
65458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65459       };
65460     } catch (Dali::DaliException e) {
65461       {
65462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65463       };
65464     } catch (...) {
65465       {
65466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65467       };
65468     }
65469   }
65470
65471   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65472   return jresult;
65473 }
65474
65475
65476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65477   void * jresult ;
65478   Dali::BaseHandle arg1 ;
65479   Dali::BaseHandle *argp1 ;
65480   Dali::Toolkit::CheckBoxButton result;
65481
65482   argp1 = (Dali::BaseHandle *)jarg1;
65483   if (!argp1) {
65484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65485     return 0;
65486   }
65487   arg1 = *argp1;
65488   {
65489     try {
65490       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65491     } catch (std::out_of_range& e) {
65492       {
65493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65494       };
65495     } catch (std::exception& e) {
65496       {
65497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65498       };
65499     } catch (Dali::DaliException e) {
65500       {
65501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65502       };
65503     } catch (...) {
65504       {
65505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65506       };
65507     }
65508   }
65509
65510   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65511   return jresult;
65512 }
65513
65514
65515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65516   int jresult ;
65517   int result;
65518
65519   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65520   jresult = (int)result;
65521   return jresult;
65522 }
65523
65524
65525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65526   int jresult ;
65527   int result;
65528
65529   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65530   jresult = (int)result;
65531   return jresult;
65532 }
65533
65534
65535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65536   void * jresult ;
65537   Dali::Toolkit::PushButton::Property *result = 0 ;
65538
65539   {
65540     try {
65541       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65542     } catch (std::out_of_range& e) {
65543       {
65544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65545       };
65546     } catch (std::exception& e) {
65547       {
65548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65549       };
65550     } catch (Dali::DaliException e) {
65551       {
65552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65553       };
65554     } catch (...) {
65555       {
65556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65557       };
65558     }
65559   }
65560
65561   jresult = (void *)result;
65562   return jresult;
65563 }
65564
65565
65566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65567   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65568
65569   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65570   {
65571     try {
65572       delete arg1;
65573     } catch (std::out_of_range& e) {
65574       {
65575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65576       };
65577     } catch (std::exception& e) {
65578       {
65579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65580       };
65581     } catch (Dali::DaliException e) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65588       };
65589     }
65590   }
65591
65592 }
65593
65594
65595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65596   void * jresult ;
65597   Dali::Toolkit::PushButton *result = 0 ;
65598
65599   {
65600     try {
65601       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65602     } catch (std::out_of_range& e) {
65603       {
65604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65605       };
65606     } catch (std::exception& e) {
65607       {
65608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65609       };
65610     } catch (Dali::DaliException e) {
65611       {
65612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65613       };
65614     } catch (...) {
65615       {
65616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65617       };
65618     }
65619   }
65620
65621   jresult = (void *)result;
65622   return jresult;
65623 }
65624
65625
65626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65627   void * jresult ;
65628   Dali::Toolkit::PushButton *arg1 = 0 ;
65629   Dali::Toolkit::PushButton *result = 0 ;
65630
65631   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65632   if (!arg1) {
65633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65634     return 0;
65635   }
65636   {
65637     try {
65638       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65639     } catch (std::out_of_range& e) {
65640       {
65641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65642       };
65643     } catch (std::exception& e) {
65644       {
65645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65646       };
65647     } catch (Dali::DaliException e) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65650       };
65651     } catch (...) {
65652       {
65653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65654       };
65655     }
65656   }
65657
65658   jresult = (void *)result;
65659   return jresult;
65660 }
65661
65662
65663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65664   void * jresult ;
65665   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65666   Dali::Toolkit::PushButton *arg2 = 0 ;
65667   Dali::Toolkit::PushButton *result = 0 ;
65668
65669   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65670   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65671   if (!arg2) {
65672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65673     return 0;
65674   }
65675   {
65676     try {
65677       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65678     } catch (std::out_of_range& e) {
65679       {
65680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65681       };
65682     } catch (std::exception& e) {
65683       {
65684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65685       };
65686     } catch (Dali::DaliException e) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65689       };
65690     } catch (...) {
65691       {
65692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65693       };
65694     }
65695   }
65696
65697   jresult = (void *)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65703   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65704
65705   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65706   {
65707     try {
65708       delete arg1;
65709     } catch (std::out_of_range& e) {
65710       {
65711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65712       };
65713     } catch (std::exception& e) {
65714       {
65715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65716       };
65717     } catch (Dali::DaliException e) {
65718       {
65719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65720       };
65721     } catch (...) {
65722       {
65723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65724       };
65725     }
65726   }
65727
65728 }
65729
65730
65731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65732   void * jresult ;
65733   Dali::Toolkit::PushButton result;
65734
65735   {
65736     try {
65737       result = Dali::Toolkit::PushButton::New();
65738     } catch (std::out_of_range& e) {
65739       {
65740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65741       };
65742     } catch (std::exception& e) {
65743       {
65744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65745       };
65746     } catch (Dali::DaliException e) {
65747       {
65748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65749       };
65750     } catch (...) {
65751       {
65752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65753       };
65754     }
65755   }
65756
65757   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65758   return jresult;
65759 }
65760
65761
65762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65763   void * jresult ;
65764   Dali::BaseHandle arg1 ;
65765   Dali::BaseHandle *argp1 ;
65766   Dali::Toolkit::PushButton result;
65767
65768   argp1 = (Dali::BaseHandle *)jarg1;
65769   if (!argp1) {
65770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65771     return 0;
65772   }
65773   arg1 = *argp1;
65774   {
65775     try {
65776       result = Dali::Toolkit::PushButton::DownCast(arg1);
65777     } catch (std::out_of_range& e) {
65778       {
65779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (std::exception& e) {
65782       {
65783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65784       };
65785     } catch (Dali::DaliException e) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65788       };
65789     } catch (...) {
65790       {
65791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65792       };
65793     }
65794   }
65795
65796   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65797   return jresult;
65798 }
65799
65800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65801   void * jresult ;
65802   Dali::Toolkit::RadioButton *result = 0 ;
65803
65804   {
65805     try {
65806       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65807     } catch (std::out_of_range& e) {
65808       {
65809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65810       };
65811     } catch (std::exception& e) {
65812       {
65813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (Dali::DaliException e) {
65816       {
65817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65818       };
65819     } catch (...) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65822       };
65823     }
65824   }
65825
65826   jresult = (void *)result;
65827   return jresult;
65828 }
65829
65830
65831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65832   void * jresult ;
65833   Dali::Toolkit::RadioButton *arg1 = 0 ;
65834   Dali::Toolkit::RadioButton *result = 0 ;
65835
65836   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65837   if (!arg1) {
65838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65839     return 0;
65840   }
65841   {
65842     try {
65843       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65844     } catch (std::out_of_range& e) {
65845       {
65846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65847       };
65848     } catch (std::exception& e) {
65849       {
65850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65851       };
65852     } catch (Dali::DaliException e) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65855       };
65856     } catch (...) {
65857       {
65858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65859       };
65860     }
65861   }
65862
65863   jresult = (void *)result;
65864   return jresult;
65865 }
65866
65867
65868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65869   void * jresult ;
65870   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65871   Dali::Toolkit::RadioButton *arg2 = 0 ;
65872   Dali::Toolkit::RadioButton *result = 0 ;
65873
65874   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65875   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65876   if (!arg2) {
65877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65878     return 0;
65879   }
65880   {
65881     try {
65882       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65883     } catch (std::out_of_range& e) {
65884       {
65885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65886       };
65887     } catch (std::exception& e) {
65888       {
65889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65890       };
65891     } catch (Dali::DaliException e) {
65892       {
65893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65894       };
65895     } catch (...) {
65896       {
65897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65898       };
65899     }
65900   }
65901
65902   jresult = (void *)result;
65903   return jresult;
65904 }
65905
65906
65907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65908   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65909
65910   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65911   {
65912     try {
65913       delete arg1;
65914     } catch (std::out_of_range& e) {
65915       {
65916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65917       };
65918     } catch (std::exception& e) {
65919       {
65920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65921       };
65922     } catch (Dali::DaliException e) {
65923       {
65924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65925       };
65926     } catch (...) {
65927       {
65928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65929       };
65930     }
65931   }
65932
65933 }
65934
65935
65936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65937   void * jresult ;
65938   Dali::Toolkit::RadioButton result;
65939
65940   {
65941     try {
65942       result = Dali::Toolkit::RadioButton::New();
65943     } catch (std::out_of_range& e) {
65944       {
65945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65946       };
65947     } catch (std::exception& e) {
65948       {
65949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65950       };
65951     } catch (Dali::DaliException e) {
65952       {
65953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65954       };
65955     } catch (...) {
65956       {
65957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65958       };
65959     }
65960   }
65961
65962   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65968   void * jresult ;
65969   std::string *arg1 = 0 ;
65970   Dali::Toolkit::RadioButton result;
65971
65972   if (!jarg1) {
65973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65974     return 0;
65975   }
65976   std::string arg1_str(jarg1);
65977   arg1 = &arg1_str;
65978   {
65979     try {
65980       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65981     } catch (std::out_of_range& e) {
65982       {
65983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65984       };
65985     } catch (std::exception& e) {
65986       {
65987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65988       };
65989     } catch (Dali::DaliException e) {
65990       {
65991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65992       };
65993     } catch (...) {
65994       {
65995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65996       };
65997     }
65998   }
65999
66000   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66001
66002   //argout typemap for const std::string&
66003
66004   return jresult;
66005 }
66006
66007
66008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66009   void * jresult ;
66010   Dali::BaseHandle arg1 ;
66011   Dali::BaseHandle *argp1 ;
66012   Dali::Toolkit::RadioButton result;
66013
66014   argp1 = (Dali::BaseHandle *)jarg1;
66015   if (!argp1) {
66016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66017     return 0;
66018   }
66019   arg1 = *argp1;
66020   {
66021     try {
66022       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66023     } catch (std::out_of_range& e) {
66024       {
66025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66026       };
66027     } catch (std::exception& e) {
66028       {
66029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66030       };
66031     } catch (Dali::DaliException e) {
66032       {
66033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66034       };
66035     } catch (...) {
66036       {
66037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66038       };
66039     }
66040   }
66041
66042   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66043   return jresult;
66044 }
66045
66046
66047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66048   int jresult ;
66049   int result;
66050
66051   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66052   jresult = (int)result;
66053   return jresult;
66054 }
66055
66056
66057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66058   int jresult ;
66059   int result;
66060
66061   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66062   jresult = (int)result;
66063   return jresult;
66064 }
66065
66066
66067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66068   int jresult ;
66069   int result;
66070
66071   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66072   jresult = (int)result;
66073   return jresult;
66074 }
66075
66076
66077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66078   int jresult ;
66079   int result;
66080
66081   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66082   jresult = (int)result;
66083   return jresult;
66084 }
66085
66086
66087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66088   int jresult ;
66089   int result;
66090
66091   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66092   jresult = (int)result;
66093   return jresult;
66094 }
66095
66096
66097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66098   int jresult ;
66099   int result;
66100
66101   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66102   jresult = (int)result;
66103   return jresult;
66104 }
66105
66106
66107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66108   void * jresult ;
66109   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66110
66111   {
66112     try {
66113       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66114     } catch (std::out_of_range& e) {
66115       {
66116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66117       };
66118     } catch (std::exception& e) {
66119       {
66120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66121       };
66122     } catch (Dali::DaliException e) {
66123       {
66124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66125       };
66126     } catch (...) {
66127       {
66128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66129       };
66130     }
66131   }
66132
66133   jresult = (void *)result;
66134   return jresult;
66135 }
66136
66137
66138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66139   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66140
66141   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66142   {
66143     try {
66144       delete arg1;
66145     } catch (std::out_of_range& e) {
66146       {
66147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66148       };
66149     } catch (std::exception& e) {
66150       {
66151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66152       };
66153     } catch (Dali::DaliException e) {
66154       {
66155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66156       };
66157     } catch (...) {
66158       {
66159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66160       };
66161     }
66162   }
66163
66164 }
66165
66166
66167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66168   int jresult ;
66169   int result;
66170
66171   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66172   jresult = (int)result;
66173   return jresult;
66174 }
66175
66176
66177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66178   int jresult ;
66179   int result;
66180
66181   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66182   jresult = (int)result;
66183   return jresult;
66184 }
66185
66186
66187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66188   int jresult ;
66189   int result;
66190
66191   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66192   jresult = (int)result;
66193   return jresult;
66194 }
66195
66196
66197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66198   void * jresult ;
66199   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66200
66201   {
66202     try {
66203       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66204     } catch (std::out_of_range& e) {
66205       {
66206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66207       };
66208     } catch (std::exception& e) {
66209       {
66210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66211       };
66212     } catch (Dali::DaliException e) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66215       };
66216     } catch (...) {
66217       {
66218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66219       };
66220     }
66221   }
66222
66223   jresult = (void *)result;
66224   return jresult;
66225 }
66226
66227
66228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66229   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66230
66231   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66232   {
66233     try {
66234       delete arg1;
66235     } catch (std::out_of_range& e) {
66236       {
66237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66238       };
66239     } catch (std::exception& e) {
66240       {
66241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66242       };
66243     } catch (Dali::DaliException e) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66250       };
66251     }
66252   }
66253
66254 }
66255
66256
66257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66258   void * jresult ;
66259   Dali::Toolkit::FlexContainer *result = 0 ;
66260
66261   {
66262     try {
66263       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66264     } catch (std::out_of_range& e) {
66265       {
66266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66267       };
66268     } catch (std::exception& e) {
66269       {
66270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66271       };
66272     } catch (Dali::DaliException e) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66275       };
66276     } catch (...) {
66277       {
66278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66279       };
66280     }
66281   }
66282
66283   jresult = (void *)result;
66284   return jresult;
66285 }
66286
66287
66288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66289   void * jresult ;
66290   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66291   Dali::Toolkit::FlexContainer *result = 0 ;
66292
66293   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66294   if (!arg1) {
66295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66296     return 0;
66297   }
66298   {
66299     try {
66300       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66301     } catch (std::out_of_range& e) {
66302       {
66303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66304       };
66305     } catch (std::exception& e) {
66306       {
66307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66308       };
66309     } catch (Dali::DaliException e) {
66310       {
66311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66312       };
66313     } catch (...) {
66314       {
66315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66316       };
66317     }
66318   }
66319
66320   jresult = (void *)result;
66321   return jresult;
66322 }
66323
66324
66325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66326   void * jresult ;
66327   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66328   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66329   Dali::Toolkit::FlexContainer *result = 0 ;
66330
66331   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66332   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66333   if (!arg2) {
66334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66335     return 0;
66336   }
66337   {
66338     try {
66339       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66340     } catch (std::out_of_range& e) {
66341       {
66342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66343       };
66344     } catch (std::exception& e) {
66345       {
66346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66347       };
66348     } catch (Dali::DaliException e) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66351       };
66352     } catch (...) {
66353       {
66354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66355       };
66356     }
66357   }
66358
66359   jresult = (void *)result;
66360   return jresult;
66361 }
66362
66363
66364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66365   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66366
66367   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66368   {
66369     try {
66370       delete arg1;
66371     } catch (std::out_of_range& e) {
66372       {
66373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66374       };
66375     } catch (std::exception& e) {
66376       {
66377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66378       };
66379     } catch (Dali::DaliException e) {
66380       {
66381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66382       };
66383     } catch (...) {
66384       {
66385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66386       };
66387     }
66388   }
66389
66390 }
66391
66392
66393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66394   void * jresult ;
66395   Dali::Toolkit::FlexContainer result;
66396
66397   {
66398     try {
66399       result = Dali::Toolkit::FlexContainer::New();
66400     } catch (std::out_of_range& e) {
66401       {
66402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66403       };
66404     } catch (std::exception& e) {
66405       {
66406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66407       };
66408     } catch (Dali::DaliException e) {
66409       {
66410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66411       };
66412     } catch (...) {
66413       {
66414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66415       };
66416     }
66417   }
66418
66419   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66420   return jresult;
66421 }
66422
66423
66424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66425   void * jresult ;
66426   Dali::BaseHandle arg1 ;
66427   Dali::BaseHandle *argp1 ;
66428   Dali::Toolkit::FlexContainer result;
66429
66430   argp1 = (Dali::BaseHandle *)jarg1;
66431   if (!argp1) {
66432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66433     return 0;
66434   }
66435   arg1 = *argp1;
66436   {
66437     try {
66438       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66439     } catch (std::out_of_range& e) {
66440       {
66441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66442       };
66443     } catch (std::exception& e) {
66444       {
66445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66446       };
66447     } catch (Dali::DaliException e) {
66448       {
66449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66450       };
66451     } catch (...) {
66452       {
66453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66454       };
66455     }
66456   }
66457
66458   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66459   return jresult;
66460 }
66461
66462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66463   int jresult ;
66464   int result;
66465
66466   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66467   jresult = (int)result;
66468   return jresult;
66469 }
66470
66471
66472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66473   int jresult ;
66474   int result;
66475
66476   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66477   jresult = (int)result;
66478   return jresult;
66479 }
66480
66481
66482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66483   int jresult ;
66484   int result;
66485
66486   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66487   jresult = (int)result;
66488   return jresult;
66489 }
66490
66491
66492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66493   void * jresult ;
66494   Dali::Toolkit::ImageView::Property *result = 0 ;
66495
66496   {
66497     try {
66498       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66499     } catch (std::out_of_range& e) {
66500       {
66501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66502       };
66503     } catch (std::exception& e) {
66504       {
66505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66506       };
66507     } catch (Dali::DaliException e) {
66508       {
66509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66510       };
66511     } catch (...) {
66512       {
66513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66514       };
66515     }
66516   }
66517
66518   jresult = (void *)result;
66519   return jresult;
66520 }
66521
66522
66523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66524   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66525
66526   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66527   {
66528     try {
66529       delete arg1;
66530     } catch (std::out_of_range& e) {
66531       {
66532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (std::exception& e) {
66535       {
66536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66537       };
66538     } catch (Dali::DaliException e) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66541       };
66542     } catch (...) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66545       };
66546     }
66547   }
66548
66549 }
66550
66551
66552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66553   void * jresult ;
66554   Dali::Toolkit::ImageView *result = 0 ;
66555
66556   {
66557     try {
66558       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66559     } catch (std::out_of_range& e) {
66560       {
66561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66562       };
66563     } catch (std::exception& e) {
66564       {
66565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66566       };
66567     } catch (Dali::DaliException e) {
66568       {
66569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66570       };
66571     } catch (...) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66574       };
66575     }
66576   }
66577
66578   jresult = (void *)result;
66579   return jresult;
66580 }
66581
66582
66583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66584   void * jresult ;
66585   Dali::Toolkit::ImageView result;
66586
66587   {
66588     try {
66589       result = Dali::Toolkit::ImageView::New();
66590     } catch (std::out_of_range& e) {
66591       {
66592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66593       };
66594     } catch (std::exception& e) {
66595       {
66596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (Dali::DaliException e) {
66599       {
66600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66601       };
66602     } catch (...) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66605       };
66606     }
66607   }
66608
66609   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66610   return jresult;
66611 }
66612
66613
66614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66615   void * jresult ;
66616   std::string *arg1 = 0 ;
66617   Dali::Toolkit::ImageView result;
66618
66619   if (!jarg1) {
66620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66621     return 0;
66622   }
66623   std::string arg1_str(jarg1);
66624   arg1 = &arg1_str;
66625   {
66626     try {
66627       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66628     } catch (std::out_of_range& e) {
66629       {
66630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66631       };
66632     } catch (std::exception& e) {
66633       {
66634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66635       };
66636     } catch (Dali::DaliException e) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66639       };
66640     } catch (...) {
66641       {
66642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66643       };
66644     }
66645   }
66646
66647   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66648
66649   //argout typemap for const std::string&
66650
66651   return jresult;
66652 }
66653
66654
66655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66656   void * jresult ;
66657   std::string *arg1 = 0 ;
66658   Dali::ImageDimensions arg2 ;
66659   Dali::ImageDimensions *argp2 ;
66660   Dali::Toolkit::ImageView result;
66661
66662   if (!jarg1) {
66663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66664     return 0;
66665   }
66666   std::string arg1_str(jarg1);
66667   arg1 = &arg1_str;
66668   argp2 = (Dali::ImageDimensions *)jarg2;
66669   if (!argp2) {
66670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66671     return 0;
66672   }
66673   arg2 = *argp2;
66674   {
66675     try {
66676       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66677     } catch (std::out_of_range& e) {
66678       {
66679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66680       };
66681     } catch (std::exception& e) {
66682       {
66683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66684       };
66685     } catch (Dali::DaliException e) {
66686       {
66687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66688       };
66689     } catch (...) {
66690       {
66691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66692       };
66693     }
66694   }
66695
66696   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66697
66698   //argout typemap for const std::string&
66699
66700   return jresult;
66701 }
66702
66703
66704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66705   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66706
66707   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66708   {
66709     try {
66710       delete arg1;
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66718       };
66719     } catch (Dali::DaliException e) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66722       };
66723     } catch (...) {
66724       {
66725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66726       };
66727     }
66728   }
66729
66730 }
66731
66732
66733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66734   void * jresult ;
66735   Dali::Toolkit::ImageView *arg1 = 0 ;
66736   Dali::Toolkit::ImageView *result = 0 ;
66737
66738   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66739   if (!arg1) {
66740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66741     return 0;
66742   }
66743   {
66744     try {
66745       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66746     } catch (std::out_of_range& e) {
66747       {
66748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66749       };
66750     } catch (std::exception& e) {
66751       {
66752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66753       };
66754     } catch (Dali::DaliException e) {
66755       {
66756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66757       };
66758     } catch (...) {
66759       {
66760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66761       };
66762     }
66763   }
66764
66765   jresult = (void *)result;
66766   return jresult;
66767 }
66768
66769
66770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66771   void * jresult ;
66772   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66773   Dali::Toolkit::ImageView *arg2 = 0 ;
66774   Dali::Toolkit::ImageView *result = 0 ;
66775
66776   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66777   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66778   if (!arg2) {
66779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66780     return 0;
66781   }
66782   {
66783     try {
66784       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66785     } catch (std::out_of_range& e) {
66786       {
66787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66788       };
66789     } catch (std::exception& e) {
66790       {
66791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66792       };
66793     } catch (Dali::DaliException e) {
66794       {
66795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66796       };
66797     } catch (...) {
66798       {
66799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66800       };
66801     }
66802   }
66803
66804   jresult = (void *)result;
66805   return jresult;
66806 }
66807
66808
66809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66810   void * jresult ;
66811   Dali::BaseHandle arg1 ;
66812   Dali::BaseHandle *argp1 ;
66813   Dali::Toolkit::ImageView result;
66814
66815   argp1 = (Dali::BaseHandle *)jarg1;
66816   if (!argp1) {
66817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66818     return 0;
66819   }
66820   arg1 = *argp1;
66821   {
66822     try {
66823       result = Dali::Toolkit::ImageView::DownCast(arg1);
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66831       };
66832     } catch (Dali::DaliException e) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66835       };
66836     } catch (...) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66839       };
66840     }
66841   }
66842
66843   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66844   return jresult;
66845 }
66846
66847
66848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66849   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66850   std::string *arg2 = 0 ;
66851
66852   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66853   if (!jarg2) {
66854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66855     return ;
66856   }
66857   std::string arg2_str(jarg2);
66858   arg2 = &arg2_str;
66859   {
66860     try {
66861       (arg1)->SetImage((std::string const &)*arg2);
66862     } catch (std::out_of_range& e) {
66863       {
66864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66865       };
66866     } catch (std::exception& e) {
66867       {
66868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66869       };
66870     } catch (Dali::DaliException e) {
66871       {
66872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66873       };
66874     } catch (...) {
66875       {
66876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66877       };
66878     }
66879   }
66880
66881
66882   //argout typemap for const std::string&
66883
66884 }
66885
66886
66887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66888   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66889   std::string *arg2 = 0 ;
66890   Dali::ImageDimensions arg3 ;
66891   Dali::ImageDimensions *argp3 ;
66892
66893   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66894   if (!jarg2) {
66895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66896     return ;
66897   }
66898   std::string arg2_str(jarg2);
66899   arg2 = &arg2_str;
66900   argp3 = (Dali::ImageDimensions *)jarg3;
66901   if (!argp3) {
66902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66903     return ;
66904   }
66905   arg3 = *argp3;
66906   {
66907     try {
66908       (arg1)->SetImage((std::string const &)*arg2,arg3);
66909     } catch (std::out_of_range& e) {
66910       {
66911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66912       };
66913     } catch (std::exception& e) {
66914       {
66915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66916       };
66917     } catch (Dali::DaliException e) {
66918       {
66919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66920       };
66921     } catch (...) {
66922       {
66923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66924       };
66925     }
66926   }
66927
66928
66929   //argout typemap for const std::string&
66930
66931 }
66932
66933
66934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66935   int jresult ;
66936   int result;
66937
66938   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66939   jresult = (int)result;
66940   return jresult;
66941 }
66942
66943
66944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66945   int jresult ;
66946   int result;
66947
66948   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66949   jresult = (int)result;
66950   return jresult;
66951 }
66952
66953
66954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66955   int jresult ;
66956   int result;
66957
66958   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66959   jresult = (int)result;
66960   return jresult;
66961 }
66962
66963
66964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66965   int jresult ;
66966   int result;
66967
66968   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66969   jresult = (int)result;
66970   return jresult;
66971 }
66972
66973
66974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66975   int jresult ;
66976   int result;
66977
66978   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66979   jresult = (int)result;
66980   return jresult;
66981 }
66982
66983
66984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66985   int jresult ;
66986   int result;
66987
66988   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66989   jresult = (int)result;
66990   return jresult;
66991 }
66992
66993
66994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66995   int jresult ;
66996   int result;
66997
66998   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66999   jresult = (int)result;
67000   return jresult;
67001 }
67002
67003
67004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67005   int jresult ;
67006   int result;
67007
67008   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67009   jresult = (int)result;
67010   return jresult;
67011 }
67012
67013
67014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67015   void * jresult ;
67016   Dali::Toolkit::Model3dView::Property *result = 0 ;
67017
67018   {
67019     try {
67020       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67021     } catch (std::out_of_range& e) {
67022       {
67023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67024       };
67025     } catch (std::exception& e) {
67026       {
67027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67028       };
67029     } catch (Dali::DaliException e) {
67030       {
67031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67032       };
67033     } catch (...) {
67034       {
67035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67036       };
67037     }
67038   }
67039
67040   jresult = (void *)result;
67041   return jresult;
67042 }
67043
67044
67045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67046   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67047
67048   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67049   {
67050     try {
67051       delete arg1;
67052     } catch (std::out_of_range& e) {
67053       {
67054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67055       };
67056     } catch (std::exception& e) {
67057       {
67058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67059       };
67060     } catch (Dali::DaliException e) {
67061       {
67062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67063       };
67064     } catch (...) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67067       };
67068     }
67069   }
67070
67071 }
67072
67073
67074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67075   void * jresult ;
67076   Dali::Toolkit::Model3dView result;
67077
67078   {
67079     try {
67080       result = Dali::Toolkit::Model3dView::New();
67081     } catch (std::out_of_range& e) {
67082       {
67083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67084       };
67085     } catch (std::exception& e) {
67086       {
67087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67088       };
67089     } catch (Dali::DaliException e) {
67090       {
67091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67092       };
67093     } catch (...) {
67094       {
67095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67096       };
67097     }
67098   }
67099
67100   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67101   return jresult;
67102 }
67103
67104
67105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67106   void * jresult ;
67107   std::string *arg1 = 0 ;
67108   std::string *arg2 = 0 ;
67109   std::string *arg3 = 0 ;
67110   Dali::Toolkit::Model3dView result;
67111
67112   if (!jarg1) {
67113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67114     return 0;
67115   }
67116   std::string arg1_str(jarg1);
67117   arg1 = &arg1_str;
67118   if (!jarg2) {
67119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67120     return 0;
67121   }
67122   std::string arg2_str(jarg2);
67123   arg2 = &arg2_str;
67124   if (!jarg3) {
67125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67126     return 0;
67127   }
67128   std::string arg3_str(jarg3);
67129   arg3 = &arg3_str;
67130   {
67131     try {
67132       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67133     } catch (std::out_of_range& e) {
67134       {
67135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67136       };
67137     } catch (std::exception& e) {
67138       {
67139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67140       };
67141     } catch (Dali::DaliException e) {
67142       {
67143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67144       };
67145     } catch (...) {
67146       {
67147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67148       };
67149     }
67150   }
67151
67152   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67153
67154   //argout typemap for const std::string&
67155
67156
67157   //argout typemap for const std::string&
67158
67159
67160   //argout typemap for const std::string&
67161
67162   return jresult;
67163 }
67164
67165
67166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67167   void * jresult ;
67168   Dali::Toolkit::Model3dView *result = 0 ;
67169
67170   {
67171     try {
67172       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67173     } catch (std::out_of_range& e) {
67174       {
67175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67176       };
67177     } catch (std::exception& e) {
67178       {
67179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67180       };
67181     } catch (Dali::DaliException e) {
67182       {
67183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67184       };
67185     } catch (...) {
67186       {
67187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67188       };
67189     }
67190   }
67191
67192   jresult = (void *)result;
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67198   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67199
67200   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67201   {
67202     try {
67203       delete arg1;
67204     } catch (std::out_of_range& e) {
67205       {
67206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67207       };
67208     } catch (std::exception& e) {
67209       {
67210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67211       };
67212     } catch (Dali::DaliException e) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67215       };
67216     } catch (...) {
67217       {
67218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67219       };
67220     }
67221   }
67222
67223 }
67224
67225
67226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67227   void * jresult ;
67228   Dali::Toolkit::Model3dView *arg1 = 0 ;
67229   Dali::Toolkit::Model3dView *result = 0 ;
67230
67231   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67232   if (!arg1) {
67233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67234     return 0;
67235   }
67236   {
67237     try {
67238       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67239     } catch (std::out_of_range& e) {
67240       {
67241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67242       };
67243     } catch (std::exception& e) {
67244       {
67245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67246       };
67247     } catch (Dali::DaliException e) {
67248       {
67249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67250       };
67251     } catch (...) {
67252       {
67253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67254       };
67255     }
67256   }
67257
67258   jresult = (void *)result;
67259   return jresult;
67260 }
67261
67262
67263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67264   void * jresult ;
67265   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67266   Dali::Toolkit::Model3dView *arg2 = 0 ;
67267   Dali::Toolkit::Model3dView *result = 0 ;
67268
67269   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67270   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67271   if (!arg2) {
67272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67273     return 0;
67274   }
67275   {
67276     try {
67277       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67278     } catch (std::out_of_range& e) {
67279       {
67280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (std::exception& e) {
67283       {
67284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67285       };
67286     } catch (Dali::DaliException e) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67289       };
67290     } catch (...) {
67291       {
67292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67293       };
67294     }
67295   }
67296
67297   jresult = (void *)result;
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67303   void * jresult ;
67304   Dali::BaseHandle arg1 ;
67305   Dali::BaseHandle *argp1 ;
67306   Dali::Toolkit::Model3dView result;
67307
67308   argp1 = (Dali::BaseHandle *)jarg1;
67309   if (!argp1) {
67310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67311     return 0;
67312   }
67313   arg1 = *argp1;
67314   {
67315     try {
67316       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67317     } catch (std::out_of_range& e) {
67318       {
67319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67320       };
67321     } catch (std::exception& e) {
67322       {
67323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67324       };
67325     } catch (Dali::DaliException e) {
67326       {
67327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67328       };
67329     } catch (...) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67332       };
67333     }
67334   }
67335
67336   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67337   return jresult;
67338 }
67339
67340
67341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67342   int jresult ;
67343   int result;
67344
67345   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67346   jresult = (int)result;
67347   return jresult;
67348 }
67349
67350
67351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67352   int jresult ;
67353   int result;
67354
67355   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67356   jresult = (int)result;
67357   return jresult;
67358 }
67359
67360
67361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67362   int jresult ;
67363   int result;
67364
67365   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67366   jresult = (int)result;
67367   return jresult;
67368 }
67369
67370
67371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67372   int jresult ;
67373   int result;
67374
67375   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67376   jresult = (int)result;
67377   return jresult;
67378 }
67379
67380
67381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67382   int jresult ;
67383   int result;
67384
67385   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67386   jresult = (int)result;
67387   return jresult;
67388 }
67389
67390
67391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67392   int jresult ;
67393   int result;
67394
67395   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67396   jresult = (int)result;
67397   return jresult;
67398 }
67399
67400
67401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67402   int jresult ;
67403   int result;
67404
67405   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67406   jresult = (int)result;
67407   return jresult;
67408 }
67409
67410
67411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67412   int jresult ;
67413   int result;
67414
67415   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67416   jresult = (int)result;
67417   return jresult;
67418 }
67419
67420
67421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67422   int jresult ;
67423   int result;
67424
67425   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67426   jresult = (int)result;
67427   return jresult;
67428 }
67429
67430
67431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67432   void * jresult ;
67433   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67434
67435   {
67436     try {
67437       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67438     } catch (std::out_of_range& e) {
67439       {
67440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67441       };
67442     } catch (std::exception& e) {
67443       {
67444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67445       };
67446     } catch (Dali::DaliException e) {
67447       {
67448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67449       };
67450     } catch (...) {
67451       {
67452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67453       };
67454     }
67455   }
67456
67457   jresult = (void *)result;
67458   return jresult;
67459 }
67460
67461
67462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67463   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67464
67465   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67466   {
67467     try {
67468       delete arg1;
67469     } catch (std::out_of_range& e) {
67470       {
67471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67472       };
67473     } catch (std::exception& e) {
67474       {
67475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67476       };
67477     } catch (Dali::DaliException e) {
67478       {
67479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67480       };
67481     } catch (...) {
67482       {
67483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67484       };
67485     }
67486   }
67487
67488 }
67489
67490
67491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67492   void * jresult ;
67493   Dali::Toolkit::ScrollBar *result = 0 ;
67494
67495   {
67496     try {
67497       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67498     } catch (std::out_of_range& e) {
67499       {
67500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (std::exception& e) {
67503       {
67504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67505       };
67506     } catch (Dali::DaliException e) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67509       };
67510     } catch (...) {
67511       {
67512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67513       };
67514     }
67515   }
67516
67517   jresult = (void *)result;
67518   return jresult;
67519 }
67520
67521
67522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67523   void * jresult ;
67524   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67525   Dali::Toolkit::ScrollBar *result = 0 ;
67526
67527   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67528   if (!arg1) {
67529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67530     return 0;
67531   }
67532   {
67533     try {
67534       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67535     } catch (std::out_of_range& e) {
67536       {
67537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67538       };
67539     } catch (std::exception& e) {
67540       {
67541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67542       };
67543     } catch (Dali::DaliException e) {
67544       {
67545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67546       };
67547     } catch (...) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67550       };
67551     }
67552   }
67553
67554   jresult = (void *)result;
67555   return jresult;
67556 }
67557
67558
67559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67560   void * jresult ;
67561   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67562   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67563   Dali::Toolkit::ScrollBar *result = 0 ;
67564
67565   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67566   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67567   if (!arg2) {
67568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67569     return 0;
67570   }
67571   {
67572     try {
67573       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67574     } catch (std::out_of_range& e) {
67575       {
67576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67577       };
67578     } catch (std::exception& e) {
67579       {
67580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67581       };
67582     } catch (Dali::DaliException e) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67585       };
67586     } catch (...) {
67587       {
67588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67589       };
67590     }
67591   }
67592
67593   jresult = (void *)result;
67594   return jresult;
67595 }
67596
67597
67598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67599   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67600
67601   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67602   {
67603     try {
67604       delete arg1;
67605     } catch (std::out_of_range& e) {
67606       {
67607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67608       };
67609     } catch (std::exception& e) {
67610       {
67611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67612       };
67613     } catch (Dali::DaliException e) {
67614       {
67615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67616       };
67617     } catch (...) {
67618       {
67619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67620       };
67621     }
67622   }
67623
67624 }
67625
67626
67627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67628   void * jresult ;
67629   Dali::Toolkit::ScrollBar::Direction arg1 ;
67630   Dali::Toolkit::ScrollBar result;
67631
67632   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67633   {
67634     try {
67635       result = Dali::Toolkit::ScrollBar::New(arg1);
67636     } catch (std::out_of_range& e) {
67637       {
67638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67639       };
67640     } catch (std::exception& e) {
67641       {
67642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67643       };
67644     } catch (Dali::DaliException e) {
67645       {
67646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67647       };
67648     } catch (...) {
67649       {
67650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67651       };
67652     }
67653   }
67654
67655   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67656   return jresult;
67657 }
67658
67659
67660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67661   void * jresult ;
67662   Dali::Toolkit::ScrollBar result;
67663
67664   {
67665     try {
67666       result = Dali::Toolkit::ScrollBar::New();
67667     } catch (std::out_of_range& e) {
67668       {
67669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67670       };
67671     } catch (std::exception& e) {
67672       {
67673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67674       };
67675     } catch (Dali::DaliException e) {
67676       {
67677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67678       };
67679     } catch (...) {
67680       {
67681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67682       };
67683     }
67684   }
67685
67686   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67687   return jresult;
67688 }
67689
67690
67691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67692   void * jresult ;
67693   Dali::BaseHandle arg1 ;
67694   Dali::BaseHandle *argp1 ;
67695   Dali::Toolkit::ScrollBar result;
67696
67697   argp1 = (Dali::BaseHandle *)jarg1;
67698   if (!argp1) {
67699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67700     return 0;
67701   }
67702   arg1 = *argp1;
67703   {
67704     try {
67705       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67706     } catch (std::out_of_range& e) {
67707       {
67708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (std::exception& e) {
67711       {
67712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67713       };
67714     } catch (Dali::DaliException e) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67717       };
67718     } catch (...) {
67719       {
67720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67721       };
67722     }
67723   }
67724
67725   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67726   return jresult;
67727 }
67728
67729
67730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67731   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67732   Dali::Handle arg2 ;
67733   Dali::Property::Index arg3 ;
67734   Dali::Property::Index arg4 ;
67735   Dali::Property::Index arg5 ;
67736   Dali::Property::Index arg6 ;
67737   Dali::Handle *argp2 ;
67738
67739   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67740   argp2 = (Dali::Handle *)jarg2;
67741   if (!argp2) {
67742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67743     return ;
67744   }
67745   arg2 = *argp2;
67746   arg3 = (Dali::Property::Index)jarg3;
67747   arg4 = (Dali::Property::Index)jarg4;
67748   arg5 = (Dali::Property::Index)jarg5;
67749   arg6 = (Dali::Property::Index)jarg6;
67750   {
67751     try {
67752       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67753     } catch (std::out_of_range& e) {
67754       {
67755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67756       };
67757     } catch (std::exception& e) {
67758       {
67759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67760       };
67761     } catch (Dali::DaliException e) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67764       };
67765     } catch (...) {
67766       {
67767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67768       };
67769     }
67770   }
67771
67772 }
67773
67774
67775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67776   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67777   Dali::Actor arg2 ;
67778   Dali::Actor *argp2 ;
67779
67780   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67781   argp2 = (Dali::Actor *)jarg2;
67782   if (!argp2) {
67783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67784     return ;
67785   }
67786   arg2 = *argp2;
67787   {
67788     try {
67789       (arg1)->SetScrollIndicator(arg2);
67790     } catch (std::out_of_range& e) {
67791       {
67792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67793       };
67794     } catch (std::exception& e) {
67795       {
67796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67797       };
67798     } catch (Dali::DaliException e) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67801       };
67802     } catch (...) {
67803       {
67804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67805       };
67806     }
67807   }
67808
67809 }
67810
67811
67812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67813   void * jresult ;
67814   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67815   Dali::Actor result;
67816
67817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67818   {
67819     try {
67820       result = (arg1)->GetScrollIndicator();
67821     } catch (std::out_of_range& e) {
67822       {
67823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67824       };
67825     } catch (std::exception& e) {
67826       {
67827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67828       };
67829     } catch (Dali::DaliException e) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67832       };
67833     } catch (...) {
67834       {
67835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67836       };
67837     }
67838   }
67839
67840   jresult = new Dali::Actor((const Dali::Actor &)result);
67841   return jresult;
67842 }
67843
67844
67845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67846   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67847   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67848
67849   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67850   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67851   if (!arg2) {
67852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67853     return ;
67854   }
67855   {
67856     try {
67857       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67858     } catch (std::out_of_range& e) {
67859       {
67860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67861       };
67862     } catch (std::exception& e) {
67863       {
67864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67865       };
67866     } catch (Dali::DaliException e) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67869       };
67870     } catch (...) {
67871       {
67872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67873       };
67874     }
67875   }
67876
67877 }
67878
67879
67880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67881   void * jresult ;
67882   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67883
67884   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67885   {
67886     try {
67887       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()));
67888     } catch (std::out_of_range& e) {
67889       {
67890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67891       };
67892     } catch (std::exception& e) {
67893       {
67894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (...) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67899       };
67900     }
67901   }
67902   return jresult;
67903 }
67904
67905
67906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67907   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67908   Dali::Toolkit::ScrollBar::Direction arg2 ;
67909
67910   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67911   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67912   {
67913     try {
67914       (arg1)->SetScrollDirection(arg2);
67915     } catch (std::out_of_range& e) {
67916       {
67917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67918       };
67919     } catch (std::exception& e) {
67920       {
67921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67922       };
67923     } catch (Dali::DaliException e) {
67924       {
67925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67926       };
67927     } catch (...) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67930       };
67931     }
67932   }
67933
67934 }
67935
67936
67937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67938   int jresult ;
67939   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67940   Dali::Toolkit::ScrollBar::Direction result;
67941
67942   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67943   {
67944     try {
67945       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67946     } catch (std::out_of_range& e) {
67947       {
67948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67949       };
67950     } catch (std::exception& e) {
67951       {
67952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67953       };
67954     } catch (Dali::DaliException e) {
67955       {
67956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67957       };
67958     } catch (...) {
67959       {
67960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67961       };
67962     }
67963   }
67964
67965   jresult = (int)result;
67966   return jresult;
67967 }
67968
67969
67970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67971   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67972   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67973
67974   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67975   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67976   {
67977     try {
67978       (arg1)->SetIndicatorHeightPolicy(arg2);
67979     } catch (std::out_of_range& e) {
67980       {
67981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67982       };
67983     } catch (std::exception& e) {
67984       {
67985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67986       };
67987     } catch (Dali::DaliException e) {
67988       {
67989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67990       };
67991     } catch (...) {
67992       {
67993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67994       };
67995     }
67996   }
67997
67998 }
67999
68000
68001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68002   int jresult ;
68003   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68004   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68005
68006   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68007   {
68008     try {
68009       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68010     } catch (std::out_of_range& e) {
68011       {
68012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68013       };
68014     } catch (std::exception& e) {
68015       {
68016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68017       };
68018     } catch (Dali::DaliException e) {
68019       {
68020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68021       };
68022     } catch (...) {
68023       {
68024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68025       };
68026     }
68027   }
68028
68029   jresult = (int)result;
68030   return jresult;
68031 }
68032
68033
68034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68035   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68036   float arg2 ;
68037
68038   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68039   arg2 = (float)jarg2;
68040   {
68041     try {
68042       (arg1)->SetIndicatorFixedHeight(arg2);
68043     } catch (std::out_of_range& e) {
68044       {
68045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68046       };
68047     } catch (std::exception& e) {
68048       {
68049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68050       };
68051     } catch (Dali::DaliException e) {
68052       {
68053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68054       };
68055     } catch (...) {
68056       {
68057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68058       };
68059     }
68060   }
68061
68062 }
68063
68064
68065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68066   float jresult ;
68067   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68068   float result;
68069
68070   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68071   {
68072     try {
68073       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68074     } catch (std::out_of_range& e) {
68075       {
68076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68077       };
68078     } catch (std::exception& e) {
68079       {
68080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (Dali::DaliException e) {
68083       {
68084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68085       };
68086     } catch (...) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68089       };
68090     }
68091   }
68092
68093   jresult = result;
68094   return jresult;
68095 }
68096
68097
68098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68099   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68100   float arg2 ;
68101
68102   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68103   arg2 = (float)jarg2;
68104   {
68105     try {
68106       (arg1)->SetIndicatorShowDuration(arg2);
68107     } catch (std::out_of_range& e) {
68108       {
68109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68110       };
68111     } catch (std::exception& e) {
68112       {
68113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68114       };
68115     } catch (Dali::DaliException e) {
68116       {
68117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68118       };
68119     } catch (...) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68122       };
68123     }
68124   }
68125
68126 }
68127
68128
68129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68130   float jresult ;
68131   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68132   float result;
68133
68134   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68135   {
68136     try {
68137       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68138     } catch (std::out_of_range& e) {
68139       {
68140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68141       };
68142     } catch (std::exception& e) {
68143       {
68144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68145       };
68146     } catch (Dali::DaliException e) {
68147       {
68148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68149       };
68150     } catch (...) {
68151       {
68152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68153       };
68154     }
68155   }
68156
68157   jresult = result;
68158   return jresult;
68159 }
68160
68161
68162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68163   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68164   float arg2 ;
68165
68166   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68167   arg2 = (float)jarg2;
68168   {
68169     try {
68170       (arg1)->SetIndicatorHideDuration(arg2);
68171     } catch (std::out_of_range& e) {
68172       {
68173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68174       };
68175     } catch (std::exception& e) {
68176       {
68177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68178       };
68179     } catch (Dali::DaliException e) {
68180       {
68181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68186       };
68187     }
68188   }
68189
68190 }
68191
68192
68193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68194   float jresult ;
68195   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68196   float result;
68197
68198   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68199   {
68200     try {
68201       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68202     } catch (std::out_of_range& e) {
68203       {
68204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (std::exception& e) {
68207       {
68208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (Dali::DaliException e) {
68211       {
68212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68213       };
68214     } catch (...) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68217       };
68218     }
68219   }
68220
68221   jresult = result;
68222   return jresult;
68223 }
68224
68225
68226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68227   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68228
68229   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68230   {
68231     try {
68232       (arg1)->ShowIndicator();
68233     } catch (std::out_of_range& e) {
68234       {
68235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68236       };
68237     } catch (std::exception& e) {
68238       {
68239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68240       };
68241     } catch (Dali::DaliException e) {
68242       {
68243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68244       };
68245     } catch (...) {
68246       {
68247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68248       };
68249     }
68250   }
68251
68252 }
68253
68254
68255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68256   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68257
68258   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68259   {
68260     try {
68261       (arg1)->HideIndicator();
68262     } catch (std::out_of_range& e) {
68263       {
68264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68265       };
68266     } catch (std::exception& e) {
68267       {
68268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68269       };
68270     } catch (Dali::DaliException e) {
68271       {
68272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68273       };
68274     } catch (...) {
68275       {
68276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68277       };
68278     }
68279   }
68280
68281 }
68282
68283
68284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68285   void * jresult ;
68286   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68287   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68288
68289   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68290   {
68291     try {
68292       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68293     } catch (std::out_of_range& e) {
68294       {
68295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (std::exception& e) {
68298       {
68299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68300       };
68301     } catch (Dali::DaliException e) {
68302       {
68303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68304       };
68305     } catch (...) {
68306       {
68307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68308       };
68309     }
68310   }
68311
68312   jresult = (void *)result;
68313   return jresult;
68314 }
68315
68316
68317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68318   void * jresult ;
68319   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68320   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68321
68322   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68323   {
68324     try {
68325       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68326     } catch (std::out_of_range& e) {
68327       {
68328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (std::exception& e) {
68331       {
68332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68333       };
68334     } catch (Dali::DaliException e) {
68335       {
68336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68337       };
68338     } catch (...) {
68339       {
68340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68341       };
68342     }
68343   }
68344
68345   jresult = (void *)result;
68346   return jresult;
68347 }
68348
68349
68350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68351   int jresult ;
68352   int result;
68353
68354   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68355   jresult = (int)result;
68356   return jresult;
68357 }
68358
68359
68360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68361   int jresult ;
68362   int result;
68363
68364   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68365   jresult = (int)result;
68366   return jresult;
68367 }
68368
68369
68370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68371   int jresult ;
68372   int result;
68373
68374   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68375   jresult = (int)result;
68376   return jresult;
68377 }
68378
68379
68380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68381   int jresult ;
68382   int result;
68383
68384   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68385   jresult = (int)result;
68386   return jresult;
68387 }
68388
68389
68390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68391   int jresult ;
68392   int result;
68393
68394   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68395   jresult = (int)result;
68396   return jresult;
68397 }
68398
68399
68400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68401   int jresult ;
68402   int result;
68403
68404   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68405   jresult = (int)result;
68406   return jresult;
68407 }
68408
68409
68410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68411   int jresult ;
68412   int result;
68413
68414   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68415   jresult = (int)result;
68416   return jresult;
68417 }
68418
68419
68420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68421   int jresult ;
68422   int result;
68423
68424   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68425   jresult = (int)result;
68426   return jresult;
68427 }
68428
68429
68430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68431   int jresult ;
68432   int result;
68433
68434   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68435   jresult = (int)result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68441   int jresult ;
68442   int result;
68443
68444   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68445   jresult = (int)result;
68446   return jresult;
68447 }
68448
68449
68450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68451   int jresult ;
68452   int result;
68453
68454   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68455   jresult = (int)result;
68456   return jresult;
68457 }
68458
68459
68460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68461   int jresult ;
68462   int result;
68463
68464   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68465   jresult = (int)result;
68466   return jresult;
68467 }
68468
68469
68470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68471   int jresult ;
68472   int result;
68473
68474   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68475   jresult = (int)result;
68476   return jresult;
68477 }
68478
68479
68480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68481   int jresult ;
68482   int result;
68483
68484   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68485   jresult = (int)result;
68486   return jresult;
68487 }
68488
68489
68490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68491   void * jresult ;
68492   Dali::Toolkit::Scrollable::Property *result = 0 ;
68493
68494   {
68495     try {
68496       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68497     } catch (std::out_of_range& e) {
68498       {
68499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68500       };
68501     } catch (std::exception& e) {
68502       {
68503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68504       };
68505     } catch (Dali::DaliException e) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68508       };
68509     } catch (...) {
68510       {
68511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68512       };
68513     }
68514   }
68515
68516   jresult = (void *)result;
68517   return jresult;
68518 }
68519
68520
68521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68522   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68523
68524   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68525   {
68526     try {
68527       delete arg1;
68528     } catch (std::out_of_range& e) {
68529       {
68530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68531       };
68532     } catch (std::exception& e) {
68533       {
68534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68535       };
68536     } catch (Dali::DaliException e) {
68537       {
68538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68543       };
68544     }
68545   }
68546
68547 }
68548
68549
68550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68551   void * jresult ;
68552   Dali::Toolkit::Scrollable *result = 0 ;
68553
68554   {
68555     try {
68556       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68557     } catch (std::out_of_range& e) {
68558       {
68559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68560       };
68561     } catch (std::exception& e) {
68562       {
68563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68564       };
68565     } catch (Dali::DaliException e) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68568       };
68569     } catch (...) {
68570       {
68571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68572       };
68573     }
68574   }
68575
68576   jresult = (void *)result;
68577   return jresult;
68578 }
68579
68580
68581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68582   void * jresult ;
68583   Dali::Toolkit::Scrollable *arg1 = 0 ;
68584   Dali::Toolkit::Scrollable *result = 0 ;
68585
68586   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68587   if (!arg1) {
68588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68589     return 0;
68590   }
68591   {
68592     try {
68593       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68594     } catch (std::out_of_range& e) {
68595       {
68596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68597       };
68598     } catch (std::exception& e) {
68599       {
68600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68601       };
68602     } catch (Dali::DaliException e) {
68603       {
68604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68605       };
68606     } catch (...) {
68607       {
68608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68609       };
68610     }
68611   }
68612
68613   jresult = (void *)result;
68614   return jresult;
68615 }
68616
68617
68618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68619   void * jresult ;
68620   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68621   Dali::Toolkit::Scrollable *arg2 = 0 ;
68622   Dali::Toolkit::Scrollable *result = 0 ;
68623
68624   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68625   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68626   if (!arg2) {
68627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68628     return 0;
68629   }
68630   {
68631     try {
68632       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68633     } catch (std::out_of_range& e) {
68634       {
68635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68636       };
68637     } catch (std::exception& e) {
68638       {
68639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68640       };
68641     } catch (Dali::DaliException e) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68644       };
68645     } catch (...) {
68646       {
68647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68648       };
68649     }
68650   }
68651
68652   jresult = (void *)result;
68653   return jresult;
68654 }
68655
68656
68657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68658   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68659
68660   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68661   {
68662     try {
68663       delete arg1;
68664     } catch (std::out_of_range& e) {
68665       {
68666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68667       };
68668     } catch (std::exception& e) {
68669       {
68670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68671       };
68672     } catch (Dali::DaliException e) {
68673       {
68674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68675       };
68676     } catch (...) {
68677       {
68678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68679       };
68680     }
68681   }
68682
68683 }
68684
68685
68686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68687   void * jresult ;
68688   Dali::BaseHandle arg1 ;
68689   Dali::BaseHandle *argp1 ;
68690   Dali::Toolkit::Scrollable result;
68691
68692   argp1 = (Dali::BaseHandle *)jarg1;
68693   if (!argp1) {
68694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68695     return 0;
68696   }
68697   arg1 = *argp1;
68698   {
68699     try {
68700       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68701     } catch (std::out_of_range& e) {
68702       {
68703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68704       };
68705     } catch (std::exception& e) {
68706       {
68707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68708       };
68709     } catch (Dali::DaliException e) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68712       };
68713     } catch (...) {
68714       {
68715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68716       };
68717     }
68718   }
68719
68720   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68721   return jresult;
68722 }
68723
68724
68725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68726   unsigned int jresult ;
68727   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68728   bool result;
68729
68730   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68731   {
68732     try {
68733       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68734     } catch (std::out_of_range& e) {
68735       {
68736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68737       };
68738     } catch (std::exception& e) {
68739       {
68740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68741       };
68742     } catch (Dali::DaliException e) {
68743       {
68744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68745       };
68746     } catch (...) {
68747       {
68748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68749       };
68750     }
68751   }
68752
68753   jresult = result;
68754   return jresult;
68755 }
68756
68757
68758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68759   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68760   bool arg2 ;
68761
68762   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68763   arg2 = jarg2 ? true : false;
68764   {
68765     try {
68766       (arg1)->SetOvershootEnabled(arg2);
68767     } catch (std::out_of_range& e) {
68768       {
68769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68770       };
68771     } catch (std::exception& e) {
68772       {
68773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68774       };
68775     } catch (Dali::DaliException e) {
68776       {
68777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68778       };
68779     } catch (...) {
68780       {
68781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68782       };
68783     }
68784   }
68785
68786 }
68787
68788
68789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68790   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68791   Dali::Vector4 *arg2 = 0 ;
68792
68793   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68794   arg2 = (Dali::Vector4 *)jarg2;
68795   if (!arg2) {
68796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68797     return ;
68798   }
68799   {
68800     try {
68801       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68809       };
68810     } catch (Dali::DaliException e) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68817       };
68818     }
68819   }
68820
68821 }
68822
68823
68824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68825   void * jresult ;
68826   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68827   Dali::Vector4 result;
68828
68829   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68830   {
68831     try {
68832       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68833     } catch (std::out_of_range& e) {
68834       {
68835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68836       };
68837     } catch (std::exception& e) {
68838       {
68839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68840       };
68841     } catch (Dali::DaliException e) {
68842       {
68843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68844       };
68845     } catch (...) {
68846       {
68847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68848       };
68849     }
68850   }
68851
68852   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68853   return jresult;
68854 }
68855
68856
68857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68858   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68859   float arg2 ;
68860
68861   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68862   arg2 = (float)jarg2;
68863   {
68864     try {
68865       (arg1)->SetOvershootAnimationSpeed(arg2);
68866     } catch (std::out_of_range& e) {
68867       {
68868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68869       };
68870     } catch (std::exception& e) {
68871       {
68872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68873       };
68874     } catch (Dali::DaliException e) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68877       };
68878     } catch (...) {
68879       {
68880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68881       };
68882     }
68883   }
68884
68885 }
68886
68887
68888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68889   float jresult ;
68890   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68891   float result;
68892
68893   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68894   {
68895     try {
68896       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68897     } catch (std::out_of_range& e) {
68898       {
68899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68900       };
68901     } catch (std::exception& e) {
68902       {
68903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68904       };
68905     } catch (Dali::DaliException e) {
68906       {
68907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68908       };
68909     } catch (...) {
68910       {
68911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68912       };
68913     }
68914   }
68915
68916   jresult = result;
68917   return jresult;
68918 }
68919
68920
68921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68922   void * jresult ;
68923   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68924   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68925
68926   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68927   {
68928     try {
68929       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68930     } catch (std::out_of_range& e) {
68931       {
68932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68933       };
68934     } catch (std::exception& e) {
68935       {
68936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68937       };
68938     } catch (Dali::DaliException e) {
68939       {
68940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68941       };
68942     } catch (...) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68945       };
68946     }
68947   }
68948
68949   jresult = (void *)result;
68950   return jresult;
68951 }
68952
68953
68954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68955   void * jresult ;
68956   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68957   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68958
68959   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68960   {
68961     try {
68962       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68963     } catch (std::out_of_range& e) {
68964       {
68965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68966       };
68967     } catch (std::exception& e) {
68968       {
68969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68970       };
68971     } catch (Dali::DaliException e) {
68972       {
68973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68974       };
68975     } catch (...) {
68976       {
68977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68978       };
68979     }
68980   }
68981
68982   jresult = (void *)result;
68983   return jresult;
68984 }
68985
68986
68987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68988   void * jresult ;
68989   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68990   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68991
68992   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68993   {
68994     try {
68995       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68996     } catch (std::out_of_range& e) {
68997       {
68998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68999       };
69000     } catch (std::exception& e) {
69001       {
69002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69003       };
69004     } catch (Dali::DaliException e) {
69005       {
69006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69007       };
69008     } catch (...) {
69009       {
69010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69011       };
69012     }
69013   }
69014
69015   jresult = (void *)result;
69016   return jresult;
69017 }
69018
69019
69020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69021   unsigned int jresult ;
69022   Dali::Toolkit::ControlOrientation::Type arg1 ;
69023   bool result;
69024
69025   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69026   {
69027     try {
69028       result = (bool)Dali::Toolkit::IsVertical(arg1);
69029     } catch (std::out_of_range& e) {
69030       {
69031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69032       };
69033     } catch (std::exception& e) {
69034       {
69035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69036       };
69037     } catch (Dali::DaliException e) {
69038       {
69039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69040       };
69041     } catch (...) {
69042       {
69043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69044       };
69045     }
69046   }
69047
69048   jresult = result;
69049   return jresult;
69050 }
69051
69052
69053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69054   unsigned int jresult ;
69055   Dali::Toolkit::ControlOrientation::Type arg1 ;
69056   bool result;
69057
69058   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69059   {
69060     try {
69061       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69062     } catch (std::out_of_range& e) {
69063       {
69064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69065       };
69066     } catch (std::exception& e) {
69067       {
69068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69069       };
69070     } catch (Dali::DaliException e) {
69071       {
69072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69073       };
69074     } catch (...) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69077       };
69078     }
69079   }
69080
69081   jresult = result;
69082   return jresult;
69083 }
69084
69085
69086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69087   void * jresult ;
69088   unsigned int arg1 ;
69089   unsigned int arg2 ;
69090   Dali::Toolkit::ItemRange *result = 0 ;
69091
69092   arg1 = (unsigned int)jarg1;
69093   arg2 = (unsigned int)jarg2;
69094   {
69095     try {
69096       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69097     } catch (std::out_of_range& e) {
69098       {
69099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (std::exception& e) {
69102       {
69103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69104       };
69105     } catch (Dali::DaliException e) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69108       };
69109     } catch (...) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69112       };
69113     }
69114   }
69115
69116   jresult = (void *)result;
69117   return jresult;
69118 }
69119
69120
69121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69122   void * jresult ;
69123   Dali::Toolkit::ItemRange *arg1 = 0 ;
69124   Dali::Toolkit::ItemRange *result = 0 ;
69125
69126   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69127   if (!arg1) {
69128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69129     return 0;
69130   }
69131   {
69132     try {
69133       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69134     } catch (std::out_of_range& e) {
69135       {
69136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69137       };
69138     } catch (std::exception& e) {
69139       {
69140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69141       };
69142     } catch (Dali::DaliException e) {
69143       {
69144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69145       };
69146     } catch (...) {
69147       {
69148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69149       };
69150     }
69151   }
69152
69153   jresult = (void *)result;
69154   return jresult;
69155 }
69156
69157
69158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69159   void * jresult ;
69160   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69161   Dali::Toolkit::ItemRange *arg2 = 0 ;
69162   Dali::Toolkit::ItemRange *result = 0 ;
69163
69164   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69165   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69166   if (!arg2) {
69167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69168     return 0;
69169   }
69170   {
69171     try {
69172       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69173     } catch (std::out_of_range& e) {
69174       {
69175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69176       };
69177     } catch (std::exception& e) {
69178       {
69179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69180       };
69181     } catch (Dali::DaliException e) {
69182       {
69183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69184       };
69185     } catch (...) {
69186       {
69187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69188       };
69189     }
69190   }
69191
69192   jresult = (void *)result;
69193   return jresult;
69194 }
69195
69196
69197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69198   unsigned int jresult ;
69199   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69200   unsigned int arg2 ;
69201   bool result;
69202
69203   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69204   arg2 = (unsigned int)jarg2;
69205   {
69206     try {
69207       result = (bool)(arg1)->Within(arg2);
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 = result;
69228   return jresult;
69229 }
69230
69231
69232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69233   void * jresult ;
69234   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69235   Dali::Toolkit::ItemRange *arg2 = 0 ;
69236   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69237
69238   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69239   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69240   if (!arg2) {
69241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69242     return 0;
69243   }
69244   {
69245     try {
69246       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69247     } catch (std::out_of_range& e) {
69248       {
69249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69250       };
69251     } catch (std::exception& e) {
69252       {
69253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69254       };
69255     } catch (Dali::DaliException e) {
69256       {
69257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69258       };
69259     } catch (...) {
69260       {
69261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69262       };
69263     }
69264   }
69265
69266   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69267   return jresult;
69268 }
69269
69270
69271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69272   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69273   unsigned int arg2 ;
69274
69275   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69276   arg2 = (unsigned int)jarg2;
69277   if (arg1) (arg1)->begin = arg2;
69278 }
69279
69280
69281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69282   unsigned int jresult ;
69283   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69284   unsigned int result;
69285
69286   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69287   result = (unsigned int) ((arg1)->begin);
69288   jresult = result;
69289   return jresult;
69290 }
69291
69292
69293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69294   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69295   unsigned int arg2 ;
69296
69297   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69298   arg2 = (unsigned int)jarg2;
69299   if (arg1) (arg1)->end = arg2;
69300 }
69301
69302
69303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69304   unsigned int jresult ;
69305   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69306   unsigned int result;
69307
69308   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69309   result = (unsigned int) ((arg1)->end);
69310   jresult = result;
69311   return jresult;
69312 }
69313
69314
69315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69316   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69317
69318   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69319   {
69320     try {
69321       delete arg1;
69322     } catch (std::out_of_range& e) {
69323       {
69324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69325       };
69326     } catch (std::exception& e) {
69327       {
69328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69329       };
69330     } catch (Dali::DaliException e) {
69331       {
69332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69333       };
69334     } catch (...) {
69335       {
69336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69337       };
69338     }
69339   }
69340
69341 }
69342
69343
69344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69345   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69346
69347   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69348   {
69349     try {
69350       delete arg1;
69351     } catch (std::out_of_range& e) {
69352       {
69353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69354       };
69355     } catch (std::exception& e) {
69356       {
69357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69358       };
69359     } catch (Dali::DaliException e) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69362       };
69363     } catch (...) {
69364       {
69365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69366       };
69367     }
69368   }
69369
69370 }
69371
69372
69373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69374   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69375   Dali::Toolkit::ControlOrientation::Type arg2 ;
69376
69377   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69378   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69379   {
69380     try {
69381       (arg1)->SetOrientation(arg2);
69382     } catch (std::out_of_range& e) {
69383       {
69384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69385       };
69386     } catch (std::exception& e) {
69387       {
69388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69389       };
69390     } catch (Dali::DaliException e) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69393       };
69394     } catch (...) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69397       };
69398     }
69399   }
69400
69401 }
69402
69403
69404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69405   int jresult ;
69406   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69407   Dali::Toolkit::ControlOrientation::Type result;
69408
69409   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69410   {
69411     try {
69412       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69413     } catch (std::out_of_range& e) {
69414       {
69415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69416       };
69417     } catch (std::exception& e) {
69418       {
69419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69420       };
69421     } catch (Dali::DaliException e) {
69422       {
69423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69424       };
69425     } catch (...) {
69426       {
69427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69428       };
69429     }
69430   }
69431
69432   jresult = (int)result;
69433   return jresult;
69434 }
69435
69436
69437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69438   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69439   Dali::Property::Map *arg2 = 0 ;
69440
69441   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69442   arg2 = (Dali::Property::Map *)jarg2;
69443   if (!arg2) {
69444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69445     return ;
69446   }
69447   {
69448     try {
69449       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69450     } catch (std::out_of_range& e) {
69451       {
69452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69453       };
69454     } catch (std::exception& e) {
69455       {
69456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69457       };
69458     } catch (Dali::DaliException e) {
69459       {
69460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69461       };
69462     } catch (...) {
69463       {
69464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69465       };
69466     }
69467   }
69468
69469 }
69470
69471
69472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69473   void * jresult ;
69474   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69475   Dali::Property::Map result;
69476
69477   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69478   {
69479     try {
69480       result = (arg1)->GetLayoutProperties();
69481     } catch (std::out_of_range& e) {
69482       {
69483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (std::exception& e) {
69486       {
69487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69488       };
69489     } catch (Dali::DaliException e) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69492       };
69493     } catch (...) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69496       };
69497     }
69498   }
69499
69500   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69501   return jresult;
69502 }
69503
69504
69505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69506   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69507   unsigned int arg2 ;
69508   Dali::Vector3 *arg3 = 0 ;
69509   Dali::Vector3 *arg4 = 0 ;
69510
69511   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69512   arg2 = (unsigned int)jarg2;
69513   arg3 = (Dali::Vector3 *)jarg3;
69514   if (!arg3) {
69515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69516     return ;
69517   }
69518   arg4 = (Dali::Vector3 *)jarg4;
69519   if (!arg4) {
69520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69521     return ;
69522   }
69523   {
69524     try {
69525       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69526     } catch (std::out_of_range& e) {
69527       {
69528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69529       };
69530     } catch (std::exception& e) {
69531       {
69532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69533       };
69534     } catch (Dali::DaliException e) {
69535       {
69536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69537       };
69538     } catch (...) {
69539       {
69540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69541       };
69542     }
69543   }
69544
69545 }
69546
69547
69548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69549   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69550   Dali::Vector3 *arg2 = 0 ;
69551
69552   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69553   arg2 = (Dali::Vector3 *)jarg2;
69554   if (!arg2) {
69555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69556     return ;
69557   }
69558   {
69559     try {
69560       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69561     } catch (std::out_of_range& e) {
69562       {
69563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69564       };
69565     } catch (std::exception& e) {
69566       {
69567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69568       };
69569     } catch (Dali::DaliException e) {
69570       {
69571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69572       };
69573     } catch (...) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69576       };
69577     }
69578   }
69579
69580 }
69581
69582
69583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69584   float jresult ;
69585   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69586   unsigned int arg2 ;
69587   Dali::Vector3 arg3 ;
69588   Dali::Vector3 *argp3 ;
69589   float result;
69590
69591   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69592   arg2 = (unsigned int)jarg2;
69593   argp3 = (Dali::Vector3 *)jarg3;
69594   if (!argp3) {
69595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69596     return 0;
69597   }
69598   arg3 = *argp3;
69599   {
69600     try {
69601       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69602     } catch (std::out_of_range& e) {
69603       {
69604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69605       };
69606     } catch (std::exception& e) {
69607       {
69608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69609       };
69610     } catch (Dali::DaliException e) {
69611       {
69612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69613       };
69614     } catch (...) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69617       };
69618     }
69619   }
69620
69621   jresult = result;
69622   return jresult;
69623 }
69624
69625
69626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69627   float jresult ;
69628   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69629   float arg2 ;
69630   float result;
69631
69632   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69633   arg2 = (float)jarg2;
69634   {
69635     try {
69636       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69637     } catch (std::out_of_range& e) {
69638       {
69639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69640       };
69641     } catch (std::exception& e) {
69642       {
69643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (Dali::DaliException e) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655
69656   jresult = result;
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69662   float jresult ;
69663   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69664   unsigned int arg2 ;
69665   float result;
69666
69667   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69668   arg2 = (unsigned int)jarg2;
69669   {
69670     try {
69671       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69672     } catch (std::out_of_range& e) {
69673       {
69674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (std::exception& e) {
69677       {
69678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69679       };
69680     } catch (Dali::DaliException e) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69683       };
69684     } catch (...) {
69685       {
69686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69687       };
69688     }
69689   }
69690
69691   jresult = result;
69692   return jresult;
69693 }
69694
69695
69696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69697   void * jresult ;
69698   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69699   float arg2 ;
69700   Dali::Vector3 arg3 ;
69701   Dali::Vector3 *argp3 ;
69702   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69703
69704   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69705   arg2 = (float)jarg2;
69706   argp3 = (Dali::Vector3 *)jarg3;
69707   if (!argp3) {
69708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69709     return 0;
69710   }
69711   arg3 = *argp3;
69712   {
69713     try {
69714       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69715     } catch (std::out_of_range& e) {
69716       {
69717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69718       };
69719     } catch (std::exception& e) {
69720       {
69721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69722       };
69723     } catch (Dali::DaliException e) {
69724       {
69725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69726       };
69727     } catch (...) {
69728       {
69729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69730       };
69731     }
69732   }
69733
69734   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69735   return jresult;
69736 }
69737
69738
69739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69740   float jresult ;
69741   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69742   int arg2 ;
69743   float arg3 ;
69744   Dali::Vector3 *arg4 = 0 ;
69745   float result;
69746
69747   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69748   arg2 = (int)jarg2;
69749   arg3 = (float)jarg3;
69750   arg4 = (Dali::Vector3 *)jarg4;
69751   if (!arg4) {
69752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69753     return 0;
69754   }
69755   {
69756     try {
69757       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69758     } catch (std::out_of_range& e) {
69759       {
69760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69761       };
69762     } catch (std::exception& e) {
69763       {
69764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69765       };
69766     } catch (Dali::DaliException e) {
69767       {
69768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69769       };
69770     } catch (...) {
69771       {
69772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69773       };
69774     }
69775   }
69776
69777   jresult = result;
69778   return jresult;
69779 }
69780
69781
69782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69783   unsigned int jresult ;
69784   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69785   Dali::Vector3 arg2 ;
69786   Dali::Vector3 *argp2 ;
69787   unsigned int result;
69788
69789   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69790   argp2 = (Dali::Vector3 *)jarg2;
69791   if (!argp2) {
69792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69793     return 0;
69794   }
69795   arg2 = *argp2;
69796   {
69797     try {
69798       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69799     } catch (std::out_of_range& e) {
69800       {
69801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (std::exception& e) {
69804       {
69805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (Dali::DaliException e) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69814       };
69815     }
69816   }
69817
69818   jresult = result;
69819   return jresult;
69820 }
69821
69822
69823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69824   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69825   unsigned int arg2 ;
69826   Dali::Vector3 *arg3 = 0 ;
69827   Dali::Vector3 *arg4 = 0 ;
69828
69829   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69830   arg2 = (unsigned int)jarg2;
69831   arg3 = (Dali::Vector3 *)jarg3;
69832   if (!arg3) {
69833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69834     return ;
69835   }
69836   arg4 = (Dali::Vector3 *)jarg4;
69837   if (!arg4) {
69838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69839     return ;
69840   }
69841   {
69842     try {
69843       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69844     } catch (std::out_of_range& e) {
69845       {
69846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69847       };
69848     } catch (std::exception& e) {
69849       {
69850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69851       };
69852     } catch (Dali::DaliException e) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69855       };
69856     } catch (...) {
69857       {
69858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69859       };
69860     }
69861   }
69862
69863 }
69864
69865
69866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69867   void * jresult ;
69868   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69869   Dali::Degree result;
69870
69871   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69872   {
69873     try {
69874       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69875     } catch (std::out_of_range& e) {
69876       {
69877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (std::exception& e) {
69880       {
69881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69882       };
69883     } catch (Dali::DaliException e) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69886       };
69887     } catch (...) {
69888       {
69889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69890       };
69891     }
69892   }
69893
69894   jresult = new Dali::Degree((const Dali::Degree &)result);
69895   return jresult;
69896 }
69897
69898
69899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69900   float jresult ;
69901   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69902   float result;
69903
69904   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69905   {
69906     try {
69907       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69908     } catch (std::out_of_range& e) {
69909       {
69910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69911       };
69912     } catch (std::exception& e) {
69913       {
69914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (Dali::DaliException e) {
69917       {
69918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69919       };
69920     } catch (...) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69923       };
69924     }
69925   }
69926
69927   jresult = result;
69928   return jresult;
69929 }
69930
69931
69932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69933   float jresult ;
69934   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69935   float result;
69936
69937   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69938   {
69939     try {
69940       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69941     } catch (std::out_of_range& e) {
69942       {
69943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69944       };
69945     } catch (std::exception& e) {
69946       {
69947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69948       };
69949     } catch (Dali::DaliException e) {
69950       {
69951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69952       };
69953     } catch (...) {
69954       {
69955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69956       };
69957     }
69958   }
69959
69960   jresult = result;
69961   return jresult;
69962 }
69963
69964
69965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69966   float jresult ;
69967   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69968   float result;
69969
69970   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69971   {
69972     try {
69973       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69974     } catch (std::out_of_range& e) {
69975       {
69976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69977       };
69978     } catch (std::exception& e) {
69979       {
69980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69981       };
69982     } catch (Dali::DaliException e) {
69983       {
69984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69985       };
69986     } catch (...) {
69987       {
69988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69989       };
69990     }
69991   }
69992
69993   jresult = result;
69994   return jresult;
69995 }
69996
69997
69998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69999   int jresult ;
70000   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70001   int arg2 ;
70002   int arg3 ;
70003   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70004   bool arg5 ;
70005   int result;
70006
70007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70008   arg2 = (int)jarg2;
70009   arg3 = (int)jarg3;
70010   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70011   arg5 = jarg5 ? true : false;
70012   {
70013     try {
70014       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70015     } catch (std::out_of_range& e) {
70016       {
70017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (std::exception& e) {
70020       {
70021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70022       };
70023     } catch (Dali::DaliException e) {
70024       {
70025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70026       };
70027     } catch (...) {
70028       {
70029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70030       };
70031     }
70032   }
70033
70034   jresult = result;
70035   return jresult;
70036 }
70037
70038
70039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70040   float jresult ;
70041   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70042   float result;
70043
70044   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70045   {
70046     try {
70047       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (Dali::DaliException e) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70059       };
70060     } catch (...) {
70061       {
70062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70063       };
70064     }
70065   }
70066
70067   jresult = result;
70068   return jresult;
70069 }
70070
70071
70072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70073   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70074   Dali::Actor *arg2 = 0 ;
70075   int arg3 ;
70076   Dali::Vector3 *arg4 = 0 ;
70077   Dali::Actor *arg5 = 0 ;
70078
70079   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70080   arg2 = (Dali::Actor *)jarg2;
70081   if (!arg2) {
70082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70083     return ;
70084   }
70085   arg3 = (int)jarg3;
70086   arg4 = (Dali::Vector3 *)jarg4;
70087   if (!arg4) {
70088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70089     return ;
70090   }
70091   arg5 = (Dali::Actor *)jarg5;
70092   if (!arg5) {
70093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70094     return ;
70095   }
70096   {
70097     try {
70098       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70099     } catch (std::out_of_range& e) {
70100       {
70101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70102       };
70103     } catch (std::exception& e) {
70104       {
70105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70106       };
70107     } catch (Dali::DaliException e) {
70108       {
70109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70110       };
70111     } catch (...) {
70112       {
70113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70114       };
70115     }
70116   }
70117
70118 }
70119
70120
70121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70122   void * jresult ;
70123   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70124   int arg2 ;
70125   float arg3 ;
70126   Dali::Vector3 *arg4 = 0 ;
70127   Dali::Vector3 result;
70128
70129   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70130   arg2 = (int)jarg2;
70131   arg3 = (float)jarg3;
70132   arg4 = (Dali::Vector3 *)jarg4;
70133   if (!arg4) {
70134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70135     return 0;
70136   }
70137   {
70138     try {
70139       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70140     } catch (std::out_of_range& e) {
70141       {
70142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (std::exception& e) {
70145       {
70146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70147       };
70148     } catch (Dali::DaliException e) {
70149       {
70150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70151       };
70152     } catch (...) {
70153       {
70154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70155       };
70156     }
70157   }
70158
70159   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70165   void * jresult ;
70166   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70167   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70168
70169   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70170   {
70171     try {
70172       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70173     } catch (std::out_of_range& e) {
70174       {
70175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70176       };
70177     } catch (std::exception& e) {
70178       {
70179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70180       };
70181     } catch (Dali::DaliException e) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70184       };
70185     } catch (...) {
70186       {
70187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70188       };
70189     }
70190   }
70191
70192   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70193   return jresult;
70194 }
70195
70196
70197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70198   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70199
70200   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70201   {
70202     try {
70203       delete arg1;
70204     } catch (std::out_of_range& e) {
70205       {
70206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70207       };
70208     } catch (std::exception& e) {
70209       {
70210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70211       };
70212     } catch (Dali::DaliException e) {
70213       {
70214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70215       };
70216     } catch (...) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70219       };
70220     }
70221   }
70222
70223 }
70224
70225
70226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70227   unsigned int jresult ;
70228   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70229   unsigned int result;
70230
70231   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70232   {
70233     try {
70234       result = (unsigned int)(arg1)->GetNumberOfItems();
70235     } catch (std::out_of_range& e) {
70236       {
70237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70238       };
70239     } catch (std::exception& e) {
70240       {
70241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70242       };
70243     } catch (Dali::DaliException e) {
70244       {
70245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70246       };
70247     } catch (...) {
70248       {
70249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70250       };
70251     }
70252   }
70253
70254   jresult = result;
70255   return jresult;
70256 }
70257
70258
70259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70260   void * jresult ;
70261   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70262   unsigned int arg2 ;
70263   Dali::Actor result;
70264
70265   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70266   arg2 = (unsigned int)jarg2;
70267   {
70268     try {
70269       result = (arg1)->NewItem(arg2);
70270     } catch (std::out_of_range& e) {
70271       {
70272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70273       };
70274     } catch (std::exception& e) {
70275       {
70276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70277       };
70278     } catch (Dali::DaliException e) {
70279       {
70280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70281       };
70282     } catch (...) {
70283       {
70284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70285       };
70286     }
70287   }
70288
70289   jresult = new Dali::Actor((const Dali::Actor &)result);
70290   return jresult;
70291 }
70292
70293
70294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70295   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70296   unsigned int arg2 ;
70297   Dali::Actor arg3 ;
70298   Dali::Actor *argp3 ;
70299
70300   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70301   arg2 = (unsigned int)jarg2;
70302   argp3 = (Dali::Actor *)jarg3;
70303   if (!argp3) {
70304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70305     return ;
70306   }
70307   arg3 = *argp3;
70308   {
70309     try {
70310       (arg1)->ItemReleased(arg2,arg3);
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_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70334   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70335   unsigned int arg2 ;
70336   Dali::Actor arg3 ;
70337   Dali::Actor *argp3 ;
70338
70339   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70340   arg2 = (unsigned int)jarg2;
70341   argp3 = (Dali::Actor *)jarg3;
70342   if (!argp3) {
70343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70344     return ;
70345   }
70346   arg3 = *argp3;
70347   {
70348     try {
70349       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70350     } catch (std::out_of_range& e) {
70351       {
70352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70353       };
70354     } catch (std::exception& e) {
70355       {
70356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70357       };
70358     } catch (Dali::DaliException e) {
70359       {
70360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70361       };
70362     } catch (...) {
70363       {
70364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70365       };
70366     }
70367   }
70368
70369 }
70370
70371
70372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70373   void * jresult ;
70374   Dali::Toolkit::ItemFactory *result = 0 ;
70375
70376   {
70377     try {
70378       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70379     } catch (std::out_of_range& e) {
70380       {
70381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (std::exception& e) {
70384       {
70385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (Dali::DaliException e) {
70388       {
70389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70390       };
70391     } catch (...) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70394       };
70395     }
70396   }
70397
70398   jresult = (void *)result;
70399   return jresult;
70400 }
70401
70402
70403 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) {
70404   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70405   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70406   if (director) {
70407     director->swig_connect_director(callback0, callback1, callback2);
70408   }
70409 }
70410
70411
70412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70413   int jresult ;
70414   int result;
70415
70416   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70417   jresult = (int)result;
70418   return jresult;
70419 }
70420
70421
70422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70423   int jresult ;
70424   int result;
70425
70426   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70427   jresult = (int)result;
70428   return jresult;
70429 }
70430
70431
70432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70433   int jresult ;
70434   int result;
70435
70436   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70437   jresult = (int)result;
70438   return jresult;
70439 }
70440
70441
70442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70443   int jresult ;
70444   int result;
70445
70446   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70447   jresult = (int)result;
70448   return jresult;
70449 }
70450
70451
70452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70453   int jresult ;
70454   int result;
70455
70456   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70457   jresult = (int)result;
70458   return jresult;
70459 }
70460
70461
70462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70463   int jresult ;
70464   int result;
70465
70466   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70467   jresult = (int)result;
70468   return jresult;
70469 }
70470
70471
70472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70473   int jresult ;
70474   int result;
70475
70476   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70477   jresult = (int)result;
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70483   int jresult ;
70484   int result;
70485
70486   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70487   jresult = (int)result;
70488   return jresult;
70489 }
70490
70491
70492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70493   int jresult ;
70494   int result;
70495
70496   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70497   jresult = (int)result;
70498   return jresult;
70499 }
70500
70501
70502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70503   int jresult ;
70504   int result;
70505
70506   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70507   jresult = (int)result;
70508   return jresult;
70509 }
70510
70511
70512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70513   int jresult ;
70514   int result;
70515
70516   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70517   jresult = (int)result;
70518   return jresult;
70519 }
70520
70521
70522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70523   void * jresult ;
70524   Dali::Toolkit::ItemView::Property *result = 0 ;
70525
70526   {
70527     try {
70528       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70529     } catch (std::out_of_range& e) {
70530       {
70531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70532       };
70533     } catch (std::exception& e) {
70534       {
70535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70536       };
70537     } catch (Dali::DaliException e) {
70538       {
70539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70540       };
70541     } catch (...) {
70542       {
70543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70544       };
70545     }
70546   }
70547
70548   jresult = (void *)result;
70549   return jresult;
70550 }
70551
70552
70553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70554   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70555
70556   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70557   {
70558     try {
70559       delete arg1;
70560     } catch (std::out_of_range& e) {
70561       {
70562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70563       };
70564     } catch (std::exception& e) {
70565       {
70566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70567       };
70568     } catch (Dali::DaliException e) {
70569       {
70570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70571       };
70572     } catch (...) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70575       };
70576     }
70577   }
70578
70579 }
70580
70581
70582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70583   void * jresult ;
70584   Dali::Toolkit::ItemView *result = 0 ;
70585
70586   {
70587     try {
70588       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70589     } catch (std::out_of_range& e) {
70590       {
70591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70592       };
70593     } catch (std::exception& e) {
70594       {
70595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70596       };
70597     } catch (Dali::DaliException e) {
70598       {
70599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70600       };
70601     } catch (...) {
70602       {
70603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70604       };
70605     }
70606   }
70607
70608   jresult = (void *)result;
70609   return jresult;
70610 }
70611
70612
70613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70614   void * jresult ;
70615   Dali::Toolkit::ItemView *arg1 = 0 ;
70616   Dali::Toolkit::ItemView *result = 0 ;
70617
70618   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70619   if (!arg1) {
70620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70621     return 0;
70622   }
70623   {
70624     try {
70625       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70626     } catch (std::out_of_range& e) {
70627       {
70628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70629       };
70630     } catch (std::exception& e) {
70631       {
70632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (Dali::DaliException e) {
70635       {
70636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70637       };
70638     } catch (...) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70641       };
70642     }
70643   }
70644
70645   jresult = (void *)result;
70646   return jresult;
70647 }
70648
70649
70650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70651   void * jresult ;
70652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70653   Dali::Toolkit::ItemView *arg2 = 0 ;
70654   Dali::Toolkit::ItemView *result = 0 ;
70655
70656   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70657   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70658   if (!arg2) {
70659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70660     return 0;
70661   }
70662   {
70663     try {
70664       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70665     } catch (std::out_of_range& e) {
70666       {
70667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70668       };
70669     } catch (std::exception& e) {
70670       {
70671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70672       };
70673     } catch (Dali::DaliException e) {
70674       {
70675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70676       };
70677     } catch (...) {
70678       {
70679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70680       };
70681     }
70682   }
70683
70684   jresult = (void *)result;
70685   return jresult;
70686 }
70687
70688
70689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70691
70692   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70693   {
70694     try {
70695       delete arg1;
70696     } catch (std::out_of_range& e) {
70697       {
70698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70699       };
70700     } catch (std::exception& e) {
70701       {
70702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70703       };
70704     } catch (Dali::DaliException e) {
70705       {
70706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70707       };
70708     } catch (...) {
70709       {
70710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70711       };
70712     }
70713   }
70714
70715 }
70716
70717
70718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70719   void * jresult ;
70720   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70721   Dali::Toolkit::ItemView result;
70722
70723   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70724   if (!arg1) {
70725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70726     return 0;
70727   }
70728   {
70729     try {
70730       result = Dali::Toolkit::ItemView::New(*arg1);
70731     } catch (std::out_of_range& e) {
70732       {
70733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70734       };
70735     } catch (std::exception& e) {
70736       {
70737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70738       };
70739     } catch (Dali::DaliException e) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70746       };
70747     }
70748   }
70749
70750   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70751   return jresult;
70752 }
70753
70754
70755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70756   void * jresult ;
70757   Dali::BaseHandle arg1 ;
70758   Dali::BaseHandle *argp1 ;
70759   Dali::Toolkit::ItemView result;
70760
70761   argp1 = (Dali::BaseHandle *)jarg1;
70762   if (!argp1) {
70763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70764     return 0;
70765   }
70766   arg1 = *argp1;
70767   {
70768     try {
70769       result = Dali::Toolkit::ItemView::DownCast(arg1);
70770     } catch (std::out_of_range& e) {
70771       {
70772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70773       };
70774     } catch (std::exception& e) {
70775       {
70776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70777       };
70778     } catch (Dali::DaliException e) {
70779       {
70780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70781       };
70782     } catch (...) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70785       };
70786     }
70787   }
70788
70789   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70790   return jresult;
70791 }
70792
70793
70794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70795   unsigned int jresult ;
70796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70797   unsigned int result;
70798
70799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70800   {
70801     try {
70802       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70810       };
70811     } catch (Dali::DaliException e) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70814       };
70815     } catch (...) {
70816       {
70817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70818       };
70819     }
70820   }
70821
70822   jresult = result;
70823   return jresult;
70824 }
70825
70826
70827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70828   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70829   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70830
70831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70832   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70833   if (!arg2) {
70834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70835     return ;
70836   }
70837   {
70838     try {
70839       (arg1)->AddLayout(*arg2);
70840     } catch (std::out_of_range& e) {
70841       {
70842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70843       };
70844     } catch (std::exception& e) {
70845       {
70846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70847       };
70848     } catch (Dali::DaliException e) {
70849       {
70850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70851       };
70852     } catch (...) {
70853       {
70854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70855       };
70856     }
70857   }
70858
70859 }
70860
70861
70862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70863   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70864   unsigned int arg2 ;
70865
70866   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70867   arg2 = (unsigned int)jarg2;
70868   {
70869     try {
70870       (arg1)->RemoveLayout(arg2);
70871     } catch (std::out_of_range& e) {
70872       {
70873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70874       };
70875     } catch (std::exception& e) {
70876       {
70877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70878       };
70879     } catch (Dali::DaliException e) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70882       };
70883     } catch (...) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70886       };
70887     }
70888   }
70889
70890 }
70891
70892
70893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70894   void * jresult ;
70895   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70896   unsigned int arg2 ;
70897   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70898
70899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70900   arg2 = (unsigned int)jarg2;
70901   {
70902     try {
70903       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70904     } catch (std::out_of_range& e) {
70905       {
70906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70907       };
70908     } catch (std::exception& e) {
70909       {
70910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70911       };
70912     } catch (Dali::DaliException e) {
70913       {
70914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70915       };
70916     } catch (...) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70919       };
70920     }
70921   }
70922
70923   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70924   return jresult;
70925 }
70926
70927
70928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70929   void * jresult ;
70930   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70931   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70932
70933   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70934   {
70935     try {
70936       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70937     } catch (std::out_of_range& e) {
70938       {
70939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70940       };
70941     } catch (std::exception& e) {
70942       {
70943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70944       };
70945     } catch (Dali::DaliException e) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70948       };
70949     } catch (...) {
70950       {
70951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70952       };
70953     }
70954   }
70955
70956   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70957   return jresult;
70958 }
70959
70960
70961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70962   float jresult ;
70963   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70964   Dali::Toolkit::ItemId arg2 ;
70965   float result;
70966
70967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70968   arg2 = (Dali::Toolkit::ItemId)jarg2;
70969   {
70970     try {
70971       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70987       };
70988     }
70989   }
70990
70991   jresult = result;
70992   return jresult;
70993 }
70994
70995
70996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70998   unsigned int arg2 ;
70999   Dali::Vector3 arg3 ;
71000   float arg4 ;
71001   Dali::Vector3 *argp3 ;
71002
71003   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71004   arg2 = (unsigned int)jarg2;
71005   argp3 = (Dali::Vector3 *)jarg3;
71006   if (!argp3) {
71007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71008     return ;
71009   }
71010   arg3 = *argp3;
71011   arg4 = (float)jarg4;
71012   {
71013     try {
71014       (arg1)->ActivateLayout(arg2,arg3,arg4);
71015     } catch (std::out_of_range& e) {
71016       {
71017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71018       };
71019     } catch (std::exception& e) {
71020       {
71021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71022       };
71023     } catch (Dali::DaliException e) {
71024       {
71025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71026       };
71027     } catch (...) {
71028       {
71029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71030       };
71031     }
71032   }
71033
71034 }
71035
71036
71037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71038   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71039
71040   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71041   {
71042     try {
71043       (arg1)->DeactivateCurrentLayout();
71044     } catch (std::out_of_range& e) {
71045       {
71046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71047       };
71048     } catch (std::exception& e) {
71049       {
71050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71051       };
71052     } catch (Dali::DaliException e) {
71053       {
71054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71055       };
71056     } catch (...) {
71057       {
71058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71059       };
71060     }
71061   }
71062
71063 }
71064
71065
71066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71067   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71068   float arg2 ;
71069
71070   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71071   arg2 = (float)jarg2;
71072   {
71073     try {
71074       (arg1)->SetMinimumSwipeSpeed(arg2);
71075     } catch (std::out_of_range& e) {
71076       {
71077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71078       };
71079     } catch (std::exception& e) {
71080       {
71081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71082       };
71083     } catch (Dali::DaliException e) {
71084       {
71085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71086       };
71087     } catch (...) {
71088       {
71089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71090       };
71091     }
71092   }
71093
71094 }
71095
71096
71097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71098   float jresult ;
71099   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71100   float result;
71101
71102   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71103   {
71104     try {
71105       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71106     } catch (std::out_of_range& e) {
71107       {
71108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71109       };
71110     } catch (std::exception& e) {
71111       {
71112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71113       };
71114     } catch (Dali::DaliException e) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71117       };
71118     } catch (...) {
71119       {
71120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71121       };
71122     }
71123   }
71124
71125   jresult = result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71131   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71132   float arg2 ;
71133
71134   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71135   arg2 = (float)jarg2;
71136   {
71137     try {
71138       (arg1)->SetMinimumSwipeDistance(arg2);
71139     } catch (std::out_of_range& e) {
71140       {
71141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71142       };
71143     } catch (std::exception& e) {
71144       {
71145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71146       };
71147     } catch (Dali::DaliException e) {
71148       {
71149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71150       };
71151     } catch (...) {
71152       {
71153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71154       };
71155     }
71156   }
71157
71158 }
71159
71160
71161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71162   float jresult ;
71163   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71164   float result;
71165
71166   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71167   {
71168     try {
71169       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71170     } catch (std::out_of_range& e) {
71171       {
71172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (std::exception& e) {
71175       {
71176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71177       };
71178     } catch (Dali::DaliException e) {
71179       {
71180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71185       };
71186     }
71187   }
71188
71189   jresult = result;
71190   return jresult;
71191 }
71192
71193
71194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71195   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71196   float arg2 ;
71197
71198   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71199   arg2 = (float)jarg2;
71200   {
71201     try {
71202       (arg1)->SetWheelScrollDistanceStep(arg2);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71210       };
71211     } catch (Dali::DaliException e) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71214       };
71215     } catch (...) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71218       };
71219     }
71220   }
71221
71222 }
71223
71224
71225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71226   float jresult ;
71227   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71228   float result;
71229
71230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71231   {
71232     try {
71233       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71234     } catch (std::out_of_range& e) {
71235       {
71236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (std::exception& e) {
71239       {
71240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71241       };
71242     } catch (Dali::DaliException e) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71245       };
71246     } catch (...) {
71247       {
71248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71249       };
71250     }
71251   }
71252
71253   jresult = result;
71254   return jresult;
71255 }
71256
71257
71258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71259   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71260   bool arg2 ;
71261
71262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71263   arg2 = jarg2 ? true : false;
71264   {
71265     try {
71266       (arg1)->SetAnchoring(arg2);
71267     } catch (std::out_of_range& e) {
71268       {
71269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71270       };
71271     } catch (std::exception& e) {
71272       {
71273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71274       };
71275     } catch (Dali::DaliException e) {
71276       {
71277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71278       };
71279     } catch (...) {
71280       {
71281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71282       };
71283     }
71284   }
71285
71286 }
71287
71288 //// ========================= end of part 3 =============================
71289
71290 //// ========================== start part 4 ===============================
71291
71292
71293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71294   unsigned int jresult ;
71295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71296   bool result;
71297
71298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71299   {
71300     try {
71301       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71302     } catch (std::out_of_range& e) {
71303       {
71304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71305       };
71306     } catch (std::exception& e) {
71307       {
71308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71309       };
71310     } catch (Dali::DaliException e) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71313       };
71314     } catch (...) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71317       };
71318     }
71319   }
71320
71321   jresult = result;
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71327   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71328   float arg2 ;
71329
71330   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71331   arg2 = (float)jarg2;
71332   {
71333     try {
71334       (arg1)->SetAnchoringDuration(arg2);
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71342       };
71343     } catch (Dali::DaliException e) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71346       };
71347     } catch (...) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71350       };
71351     }
71352   }
71353
71354 }
71355
71356
71357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71358   float jresult ;
71359   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71360   float result;
71361
71362   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71363   {
71364     try {
71365       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71366     } catch (std::out_of_range& e) {
71367       {
71368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71369       };
71370     } catch (std::exception& e) {
71371       {
71372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71373       };
71374     } catch (Dali::DaliException e) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71377       };
71378     } catch (...) {
71379       {
71380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71381       };
71382     }
71383   }
71384
71385   jresult = result;
71386   return jresult;
71387 }
71388
71389
71390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71391   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71392   Dali::Toolkit::ItemId arg2 ;
71393   float arg3 ;
71394
71395   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71396   arg2 = (Dali::Toolkit::ItemId)jarg2;
71397   arg3 = (float)jarg3;
71398   {
71399     try {
71400       (arg1)->ScrollToItem(arg2,arg3);
71401     } catch (std::out_of_range& e) {
71402       {
71403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71404       };
71405     } catch (std::exception& e) {
71406       {
71407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71408       };
71409     } catch (Dali::DaliException e) {
71410       {
71411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71412       };
71413     } catch (...) {
71414       {
71415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71416       };
71417     }
71418   }
71419
71420 }
71421
71422
71423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71425   float arg2 ;
71426
71427   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71428   arg2 = (float)jarg2;
71429   {
71430     try {
71431       (arg1)->SetRefreshInterval(arg2);
71432     } catch (std::out_of_range& e) {
71433       {
71434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71435       };
71436     } catch (std::exception& e) {
71437       {
71438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71439       };
71440     } catch (Dali::DaliException e) {
71441       {
71442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71443       };
71444     } catch (...) {
71445       {
71446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71447       };
71448     }
71449   }
71450
71451 }
71452
71453
71454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71455   float jresult ;
71456   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71457   float result;
71458
71459   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71460   {
71461     try {
71462       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71463     } catch (std::out_of_range& e) {
71464       {
71465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71466       };
71467     } catch (std::exception& e) {
71468       {
71469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71470       };
71471     } catch (Dali::DaliException e) {
71472       {
71473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71474       };
71475     } catch (...) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71478       };
71479     }
71480   }
71481
71482   jresult = result;
71483   return jresult;
71484 }
71485
71486
71487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71488   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71489
71490   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71491   {
71492     try {
71493       (arg1)->Refresh();
71494     } catch (std::out_of_range& e) {
71495       {
71496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71497       };
71498     } catch (std::exception& e) {
71499       {
71500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71501       };
71502     } catch (Dali::DaliException e) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71505       };
71506     } catch (...) {
71507       {
71508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71509       };
71510     }
71511   }
71512
71513 }
71514
71515
71516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71517   void * jresult ;
71518   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71519   Dali::Toolkit::ItemId arg2 ;
71520   Dali::Actor result;
71521
71522   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71523   arg2 = (Dali::Toolkit::ItemId)jarg2;
71524   {
71525     try {
71526       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71527     } catch (std::out_of_range& e) {
71528       {
71529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71530       };
71531     } catch (std::exception& e) {
71532       {
71533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71534       };
71535     } catch (Dali::DaliException e) {
71536       {
71537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71538       };
71539     } catch (...) {
71540       {
71541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71542       };
71543     }
71544   }
71545
71546   jresult = new Dali::Actor((const Dali::Actor &)result);
71547   return jresult;
71548 }
71549
71550
71551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71552   unsigned int jresult ;
71553   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71554   Dali::Actor arg2 ;
71555   Dali::Actor *argp2 ;
71556   Dali::Toolkit::ItemId result;
71557
71558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71559   argp2 = (Dali::Actor *)jarg2;
71560   if (!argp2) {
71561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71562     return 0;
71563   }
71564   arg2 = *argp2;
71565   {
71566     try {
71567       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71568     } catch (std::out_of_range& e) {
71569       {
71570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71571       };
71572     } catch (std::exception& e) {
71573       {
71574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71575       };
71576     } catch (Dali::DaliException e) {
71577       {
71578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71579       };
71580     } catch (...) {
71581       {
71582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71583       };
71584     }
71585   }
71586
71587   jresult = result;
71588   return jresult;
71589 }
71590
71591
71592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71593   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71594   Dali::Toolkit::Item arg2 ;
71595   float arg3 ;
71596   Dali::Toolkit::Item *argp2 ;
71597
71598   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71599   argp2 = (Dali::Toolkit::Item *)jarg2;
71600   if (!argp2) {
71601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71602     return ;
71603   }
71604   arg2 = *argp2;
71605   arg3 = (float)jarg3;
71606   {
71607     try {
71608       (arg1)->InsertItem(arg2,arg3);
71609     } catch (std::out_of_range& e) {
71610       {
71611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (std::exception& e) {
71614       {
71615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71616       };
71617     } catch (Dali::DaliException e) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71620       };
71621     } catch (...) {
71622       {
71623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71624       };
71625     }
71626   }
71627
71628 }
71629
71630
71631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71632   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71633   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71634   float arg3 ;
71635
71636   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71637   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71638   if (!arg2) {
71639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71640     return ;
71641   }
71642   arg3 = (float)jarg3;
71643   {
71644     try {
71645       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71646     } catch (std::out_of_range& e) {
71647       {
71648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71649       };
71650     } catch (std::exception& e) {
71651       {
71652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71653       };
71654     } catch (Dali::DaliException e) {
71655       {
71656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71657       };
71658     } catch (...) {
71659       {
71660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71661       };
71662     }
71663   }
71664
71665 }
71666
71667
71668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71670   Dali::Toolkit::ItemId arg2 ;
71671   float arg3 ;
71672
71673   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71674   arg2 = (Dali::Toolkit::ItemId)jarg2;
71675   arg3 = (float)jarg3;
71676   {
71677     try {
71678       (arg1)->RemoveItem(arg2,arg3);
71679     } catch (std::out_of_range& e) {
71680       {
71681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71682       };
71683     } catch (std::exception& e) {
71684       {
71685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71686       };
71687     } catch (Dali::DaliException e) {
71688       {
71689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71690       };
71691     } catch (...) {
71692       {
71693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71694       };
71695     }
71696   }
71697
71698 }
71699
71700
71701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71702   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71703   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71704   float arg3 ;
71705
71706   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71707   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71708   if (!arg2) {
71709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71710     return ;
71711   }
71712   arg3 = (float)jarg3;
71713   {
71714     try {
71715       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71716     } catch (std::out_of_range& e) {
71717       {
71718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71719       };
71720     } catch (std::exception& e) {
71721       {
71722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71723       };
71724     } catch (Dali::DaliException e) {
71725       {
71726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71727       };
71728     } catch (...) {
71729       {
71730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71731       };
71732     }
71733   }
71734
71735 }
71736
71737
71738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71739   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71740   Dali::Toolkit::Item arg2 ;
71741   float arg3 ;
71742   Dali::Toolkit::Item *argp2 ;
71743
71744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71745   argp2 = (Dali::Toolkit::Item *)jarg2;
71746   if (!argp2) {
71747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71748     return ;
71749   }
71750   arg2 = *argp2;
71751   arg3 = (float)jarg3;
71752   {
71753     try {
71754       (arg1)->ReplaceItem(arg2,arg3);
71755     } catch (std::out_of_range& e) {
71756       {
71757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71758       };
71759     } catch (std::exception& e) {
71760       {
71761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71762       };
71763     } catch (Dali::DaliException e) {
71764       {
71765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71766       };
71767     } catch (...) {
71768       {
71769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71770       };
71771     }
71772   }
71773
71774 }
71775
71776
71777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71779   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71780   float arg3 ;
71781
71782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71783   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71784   if (!arg2) {
71785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71786     return ;
71787   }
71788   arg3 = (float)jarg3;
71789   {
71790     try {
71791       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71792     } catch (std::out_of_range& e) {
71793       {
71794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71795       };
71796     } catch (std::exception& e) {
71797       {
71798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71799       };
71800     } catch (Dali::DaliException e) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71803       };
71804     } catch (...) {
71805       {
71806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71807       };
71808     }
71809   }
71810
71811 }
71812
71813
71814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71815   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71816   Dali::Vector3 *arg2 = 0 ;
71817
71818   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71819   arg2 = (Dali::Vector3 *)jarg2;
71820   if (!arg2) {
71821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71822     return ;
71823   }
71824   {
71825     try {
71826       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71834       };
71835     } catch (Dali::DaliException e) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71842       };
71843     }
71844   }
71845
71846 }
71847
71848
71849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71850   void * jresult ;
71851   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71852   Dali::Vector3 result;
71853
71854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71855   {
71856     try {
71857       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71858     } catch (std::out_of_range& e) {
71859       {
71860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71861       };
71862     } catch (std::exception& e) {
71863       {
71864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71865       };
71866     } catch (Dali::DaliException e) {
71867       {
71868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71869       };
71870     } catch (...) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71873       };
71874     }
71875   }
71876
71877   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71878   return jresult;
71879 }
71880
71881
71882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71883   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71884   Dali::Vector3 *arg2 = 0 ;
71885
71886   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71887   arg2 = (Dali::Vector3 *)jarg2;
71888   if (!arg2) {
71889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71890     return ;
71891   }
71892   {
71893     try {
71894       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71895     } catch (std::out_of_range& e) {
71896       {
71897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71898       };
71899     } catch (std::exception& e) {
71900       {
71901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71902       };
71903     } catch (Dali::DaliException e) {
71904       {
71905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71906       };
71907     } catch (...) {
71908       {
71909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71910       };
71911     }
71912   }
71913
71914 }
71915
71916
71917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71918   void * jresult ;
71919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71920   Dali::Vector3 result;
71921
71922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71923   {
71924     try {
71925       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71926     } catch (std::out_of_range& e) {
71927       {
71928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71929       };
71930     } catch (std::exception& e) {
71931       {
71932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71933       };
71934     } catch (Dali::DaliException e) {
71935       {
71936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71941       };
71942     }
71943   }
71944
71945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71946   return jresult;
71947 }
71948
71949
71950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71952   Dali::Toolkit::ItemRange *arg2 = 0 ;
71953
71954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71955   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71956   if (!arg2) {
71957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71958     return ;
71959   }
71960   {
71961     try {
71962       (arg1)->GetItemsRange(*arg2);
71963     } catch (std::out_of_range& e) {
71964       {
71965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71966       };
71967     } catch (std::exception& e) {
71968       {
71969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71970       };
71971     } catch (Dali::DaliException e) {
71972       {
71973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71974       };
71975     } catch (...) {
71976       {
71977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71978       };
71979     }
71980   }
71981
71982 }
71983
71984
71985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71986   void * jresult ;
71987   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71988   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71989
71990   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71991   {
71992     try {
71993       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71994     } catch (std::out_of_range& e) {
71995       {
71996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71997       };
71998     } catch (std::exception& e) {
71999       {
72000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72001       };
72002     } catch (Dali::DaliException e) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72005       };
72006     } catch (...) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72009       };
72010     }
72011   }
72012
72013   jresult = (void *)result;
72014   return jresult;
72015 }
72016
72017
72018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72019   Dali::Vector3 *arg1 = 0 ;
72020   PropertyInputContainer *arg2 = 0 ;
72021
72022   arg1 = (Dali::Vector3 *)jarg1;
72023   if (!arg1) {
72024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72025     return ;
72026   }
72027   arg2 = (PropertyInputContainer *)jarg2;
72028   if (!arg2) {
72029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72030     return ;
72031   }
72032   {
72033     try {
72034       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72035     } catch (std::out_of_range& e) {
72036       {
72037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72038       };
72039     } catch (std::exception& e) {
72040       {
72041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72042       };
72043     } catch (Dali::DaliException e) {
72044       {
72045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72046       };
72047     } catch (...) {
72048       {
72049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72050       };
72051     }
72052   }
72053
72054 }
72055
72056
72057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72058   Dali::Vector3 *arg1 = 0 ;
72059   PropertyInputContainer *arg2 = 0 ;
72060
72061   arg1 = (Dali::Vector3 *)jarg1;
72062   if (!arg1) {
72063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72064     return ;
72065   }
72066   arg2 = (PropertyInputContainer *)jarg2;
72067   if (!arg2) {
72068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72069     return ;
72070   }
72071   {
72072     try {
72073       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72074     } catch (std::out_of_range& e) {
72075       {
72076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72077       };
72078     } catch (std::exception& e) {
72079       {
72080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72081       };
72082     } catch (Dali::DaliException e) {
72083       {
72084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72085       };
72086     } catch (...) {
72087       {
72088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72089       };
72090     }
72091   }
72092
72093 }
72094
72095
72096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72097   void * jresult ;
72098   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72099
72100   {
72101     try {
72102       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72103     } catch (std::out_of_range& e) {
72104       {
72105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72106       };
72107     } catch (std::exception& e) {
72108       {
72109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72110       };
72111     } catch (Dali::DaliException e) {
72112       {
72113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72114       };
72115     } catch (...) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72118       };
72119     }
72120   }
72121
72122   jresult = (void *)result;
72123   return jresult;
72124 }
72125
72126
72127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72128   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72129
72130   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72131   {
72132     try {
72133       delete arg1;
72134     } catch (std::out_of_range& e) {
72135       {
72136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72137       };
72138     } catch (std::exception& e) {
72139       {
72140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72141       };
72142     } catch (Dali::DaliException e) {
72143       {
72144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72145       };
72146     } catch (...) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72149       };
72150     }
72151   }
72152
72153 }
72154
72155
72156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72157   void * jresult ;
72158   Dali::Path arg1 ;
72159   Dali::Vector3 *arg2 = 0 ;
72160   Dali::Property::Index arg3 ;
72161   Dali::Vector3 *arg4 = 0 ;
72162   unsigned int arg5 ;
72163   Dali::Path *argp1 ;
72164   Dali::Toolkit::ScrollViewPagePathEffect result;
72165
72166   argp1 = (Dali::Path *)jarg1;
72167   if (!argp1) {
72168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72169     return 0;
72170   }
72171   arg1 = *argp1;
72172   arg2 = (Dali::Vector3 *)jarg2;
72173   if (!arg2) {
72174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72175     return 0;
72176   }
72177   arg3 = (Dali::Property::Index)jarg3;
72178   arg4 = (Dali::Vector3 *)jarg4;
72179   if (!arg4) {
72180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72181     return 0;
72182   }
72183   arg5 = (unsigned int)jarg5;
72184   {
72185     try {
72186       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72187     } catch (std::out_of_range& e) {
72188       {
72189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72190       };
72191     } catch (std::exception& e) {
72192       {
72193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72194       };
72195     } catch (Dali::DaliException e) {
72196       {
72197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72198       };
72199     } catch (...) {
72200       {
72201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72202       };
72203     }
72204   }
72205
72206   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72207   return jresult;
72208 }
72209
72210
72211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72212   void * jresult ;
72213   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72214
72215   {
72216     try {
72217       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72218     } catch (std::out_of_range& e) {
72219       {
72220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72221       };
72222     } catch (std::exception& e) {
72223       {
72224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72225       };
72226     } catch (Dali::DaliException e) {
72227       {
72228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72229       };
72230     } catch (...) {
72231       {
72232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72233       };
72234     }
72235   }
72236
72237   jresult = (void *)result;
72238   return jresult;
72239 }
72240
72241
72242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72243   void * jresult ;
72244   Dali::BaseHandle arg1 ;
72245   Dali::BaseHandle *argp1 ;
72246   Dali::Toolkit::ScrollViewPagePathEffect result;
72247
72248   argp1 = (Dali::BaseHandle *)jarg1;
72249   if (!argp1) {
72250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72251     return 0;
72252   }
72253   arg1 = *argp1;
72254   {
72255     try {
72256       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72257     } catch (std::out_of_range& e) {
72258       {
72259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72260       };
72261     } catch (std::exception& e) {
72262       {
72263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72264       };
72265     } catch (Dali::DaliException e) {
72266       {
72267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72268       };
72269     } catch (...) {
72270       {
72271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72272       };
72273     }
72274   }
72275
72276   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72277   return jresult;
72278 }
72279
72280
72281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72282   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72283   Dali::Actor arg2 ;
72284   unsigned int arg3 ;
72285   Dali::Actor *argp2 ;
72286
72287   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72288   argp2 = (Dali::Actor *)jarg2;
72289   if (!argp2) {
72290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72291     return ;
72292   }
72293   arg2 = *argp2;
72294   arg3 = (unsigned int)jarg3;
72295   {
72296     try {
72297       (arg1)->ApplyToPage(arg2,arg3);
72298     } catch (std::out_of_range& e) {
72299       {
72300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72301       };
72302     } catch (std::exception& e) {
72303       {
72304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72305       };
72306     } catch (Dali::DaliException e) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72309       };
72310     } catch (...) {
72311       {
72312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72313       };
72314     }
72315   }
72316
72317 }
72318
72319
72320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72321   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72322
72323   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72324   {
72325     try {
72326       delete arg1;
72327     } catch (std::out_of_range& e) {
72328       {
72329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72330       };
72331     } catch (std::exception& e) {
72332       {
72333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72334       };
72335     } catch (Dali::DaliException e) {
72336       {
72337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72338       };
72339     } catch (...) {
72340       {
72341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72342       };
72343     }
72344   }
72345
72346 }
72347
72348
72349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72350   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72351   Dali::Toolkit::ClampState arg2 ;
72352
72353   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72354   arg2 = (Dali::Toolkit::ClampState)jarg2;
72355   if (arg1) (arg1)->x = arg2;
72356 }
72357
72358
72359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72360   int jresult ;
72361   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72362   Dali::Toolkit::ClampState result;
72363
72364   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72365   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72366   jresult = (int)result;
72367   return jresult;
72368 }
72369
72370
72371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72372   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72373   Dali::Toolkit::ClampState arg2 ;
72374
72375   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72376   arg2 = (Dali::Toolkit::ClampState)jarg2;
72377   if (arg1) (arg1)->y = arg2;
72378 }
72379
72380
72381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72382   int jresult ;
72383   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72384   Dali::Toolkit::ClampState result;
72385
72386   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72387   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72388   jresult = (int)result;
72389   return jresult;
72390 }
72391
72392
72393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72394   void * jresult ;
72395   Dali::Toolkit::ClampState2D *result = 0 ;
72396
72397   {
72398     try {
72399       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72400     } catch (std::out_of_range& e) {
72401       {
72402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72403       };
72404     } catch (std::exception& e) {
72405       {
72406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72407       };
72408     } catch (Dali::DaliException e) {
72409       {
72410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72411       };
72412     } catch (...) {
72413       {
72414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72415       };
72416     }
72417   }
72418
72419   jresult = (void *)result;
72420   return jresult;
72421 }
72422
72423
72424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72425   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72426
72427   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72428   {
72429     try {
72430       delete arg1;
72431     } catch (std::out_of_range& e) {
72432       {
72433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72434       };
72435     } catch (std::exception& e) {
72436       {
72437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72438       };
72439     } catch (Dali::DaliException e) {
72440       {
72441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72442       };
72443     } catch (...) {
72444       {
72445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72446       };
72447     }
72448   }
72449
72450 }
72451
72452
72453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72454   void * jresult ;
72455   float arg1 ;
72456   float arg2 ;
72457   bool arg3 ;
72458   Dali::Toolkit::RulerDomain *result = 0 ;
72459
72460   arg1 = (float)jarg1;
72461   arg2 = (float)jarg2;
72462   arg3 = jarg3 ? true : false;
72463   {
72464     try {
72465       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72466     } catch (std::out_of_range& e) {
72467       {
72468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72469       };
72470     } catch (std::exception& e) {
72471       {
72472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72473       };
72474     } catch (Dali::DaliException e) {
72475       {
72476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72477       };
72478     } catch (...) {
72479       {
72480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72481       };
72482     }
72483   }
72484
72485   jresult = (void *)result;
72486   return jresult;
72487 }
72488
72489
72490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72491   void * jresult ;
72492   float arg1 ;
72493   float arg2 ;
72494   Dali::Toolkit::RulerDomain *result = 0 ;
72495
72496   arg1 = (float)jarg1;
72497   arg2 = (float)jarg2;
72498   {
72499     try {
72500       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72501     } catch (std::out_of_range& e) {
72502       {
72503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72504       };
72505     } catch (std::exception& e) {
72506       {
72507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72508       };
72509     } catch (Dali::DaliException e) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72512       };
72513     } catch (...) {
72514       {
72515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72516       };
72517     }
72518   }
72519
72520   jresult = (void *)result;
72521   return jresult;
72522 }
72523
72524
72525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72526   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72527   float arg2 ;
72528
72529   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72530   arg2 = (float)jarg2;
72531   if (arg1) (arg1)->min = arg2;
72532 }
72533
72534
72535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72536   float jresult ;
72537   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72538   float result;
72539
72540   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72541   result = (float) ((arg1)->min);
72542   jresult = result;
72543   return jresult;
72544 }
72545
72546
72547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72548   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72549   float arg2 ;
72550
72551   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72552   arg2 = (float)jarg2;
72553   if (arg1) (arg1)->max = arg2;
72554 }
72555
72556
72557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72558   float jresult ;
72559   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72560   float result;
72561
72562   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72563   result = (float) ((arg1)->max);
72564   jresult = result;
72565   return jresult;
72566 }
72567
72568
72569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72570   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72571   bool arg2 ;
72572
72573   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72574   arg2 = jarg2 ? true : false;
72575   if (arg1) (arg1)->enabled = arg2;
72576 }
72577
72578
72579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72580   unsigned int jresult ;
72581   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72582   bool result;
72583
72584   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72585   result = (bool) ((arg1)->enabled);
72586   jresult = result;
72587   return jresult;
72588 }
72589
72590
72591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72592   float jresult ;
72593   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72594   float arg2 ;
72595   float arg3 ;
72596   float arg4 ;
72597   float result;
72598
72599   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72600   arg2 = (float)jarg2;
72601   arg3 = (float)jarg3;
72602   arg4 = (float)jarg4;
72603   {
72604     try {
72605       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72606     } catch (std::out_of_range& e) {
72607       {
72608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72609       };
72610     } catch (std::exception& e) {
72611       {
72612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72613       };
72614     } catch (Dali::DaliException e) {
72615       {
72616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72617       };
72618     } catch (...) {
72619       {
72620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72621       };
72622     }
72623   }
72624
72625   jresult = result;
72626   return jresult;
72627 }
72628
72629
72630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72631   float jresult ;
72632   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72633   float arg2 ;
72634   float arg3 ;
72635   float result;
72636
72637   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72638   arg2 = (float)jarg2;
72639   arg3 = (float)jarg3;
72640   {
72641     try {
72642       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72643     } catch (std::out_of_range& e) {
72644       {
72645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72646       };
72647     } catch (std::exception& e) {
72648       {
72649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72650       };
72651     } catch (Dali::DaliException e) {
72652       {
72653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72654       };
72655     } catch (...) {
72656       {
72657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72658       };
72659     }
72660   }
72661
72662   jresult = result;
72663   return jresult;
72664 }
72665
72666
72667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72668   float jresult ;
72669   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72670   float arg2 ;
72671   float result;
72672
72673   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72674   arg2 = (float)jarg2;
72675   {
72676     try {
72677       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
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 = result;
72698   return jresult;
72699 }
72700
72701
72702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72703   float jresult ;
72704   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72705   float arg2 ;
72706   float arg3 ;
72707   float arg4 ;
72708   Dali::Toolkit::ClampState *arg5 = 0 ;
72709   float result;
72710
72711   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72712   arg2 = (float)jarg2;
72713   arg3 = (float)jarg3;
72714   arg4 = (float)jarg4;
72715   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72716   if (!arg5) {
72717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72718     return 0;
72719   }
72720   {
72721     try {
72722       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72723     } catch (std::out_of_range& e) {
72724       {
72725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72726       };
72727     } catch (std::exception& e) {
72728       {
72729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72730       };
72731     } catch (Dali::DaliException e) {
72732       {
72733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72734       };
72735     } catch (...) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72738       };
72739     }
72740   }
72741
72742   jresult = result;
72743   return jresult;
72744 }
72745
72746
72747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(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   {
72754     try {
72755       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72756     } catch (std::out_of_range& e) {
72757       {
72758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72759       };
72760     } catch (std::exception& e) {
72761       {
72762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72763       };
72764     } catch (Dali::DaliException e) {
72765       {
72766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72767       };
72768     } catch (...) {
72769       {
72770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72771       };
72772     }
72773   }
72774
72775   jresult = result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72781   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72782
72783   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72784   {
72785     try {
72786       delete arg1;
72787     } catch (std::out_of_range& e) {
72788       {
72789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72790       };
72791     } catch (std::exception& e) {
72792       {
72793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72794       };
72795     } catch (Dali::DaliException e) {
72796       {
72797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72798       };
72799     } catch (...) {
72800       {
72801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72802       };
72803     }
72804   }
72805
72806 }
72807
72808
72809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72810   float jresult ;
72811   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72812   float arg2 ;
72813   float arg3 ;
72814   float result;
72815
72816   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72817   arg2 = (float)jarg2;
72818   arg3 = (float)jarg3;
72819   {
72820     try {
72821       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72822     } catch (std::out_of_range& e) {
72823       {
72824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72825       };
72826     } catch (std::exception& e) {
72827       {
72828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72829       };
72830     } catch (Dali::DaliException e) {
72831       {
72832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72833       };
72834     } catch (...) {
72835       {
72836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72837       };
72838     }
72839   }
72840
72841   jresult = result;
72842   return jresult;
72843 }
72844
72845
72846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72847   float jresult ;
72848   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72849   float arg2 ;
72850   float result;
72851
72852   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72853   arg2 = (float)jarg2;
72854   {
72855     try {
72856       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72857     } catch (std::out_of_range& e) {
72858       {
72859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72860       };
72861     } catch (std::exception& e) {
72862       {
72863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72864       };
72865     } catch (Dali::DaliException e) {
72866       {
72867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72868       };
72869     } catch (...) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72872       };
72873     }
72874   }
72875
72876   jresult = result;
72877   return jresult;
72878 }
72879
72880
72881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72882   float jresult ;
72883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72884   unsigned int arg2 ;
72885   unsigned int *arg3 = 0 ;
72886   bool arg4 ;
72887   float result;
72888
72889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72890   arg2 = (unsigned int)jarg2;
72891   arg3 = (unsigned int *)jarg3;
72892   arg4 = jarg4 ? true : false;
72893   {
72894     try {
72895       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72896     } catch (std::out_of_range& e) {
72897       {
72898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72899       };
72900     } catch (std::exception& e) {
72901       {
72902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72903       };
72904     } catch (Dali::DaliException e) {
72905       {
72906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72907       };
72908     } catch (...) {
72909       {
72910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72911       };
72912     }
72913   }
72914
72915   jresult = result;
72916   return jresult;
72917 }
72918
72919
72920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72921   unsigned int jresult ;
72922   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72923   float arg2 ;
72924   bool arg3 ;
72925   unsigned int result;
72926
72927   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72928   arg2 = (float)jarg2;
72929   arg3 = jarg3 ? true : false;
72930   {
72931     try {
72932       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72933     } catch (std::out_of_range& e) {
72934       {
72935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72936       };
72937     } catch (std::exception& e) {
72938       {
72939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72940       };
72941     } catch (Dali::DaliException e) {
72942       {
72943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72944       };
72945     } catch (...) {
72946       {
72947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72948       };
72949     }
72950   }
72951
72952   jresult = result;
72953   return jresult;
72954 }
72955
72956
72957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72958   unsigned int jresult ;
72959   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72960   unsigned int result;
72961
72962   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72963   {
72964     try {
72965       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72966     } catch (std::out_of_range& e) {
72967       {
72968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72969       };
72970     } catch (std::exception& e) {
72971       {
72972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72973       };
72974     } catch (Dali::DaliException e) {
72975       {
72976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72977       };
72978     } catch (...) {
72979       {
72980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72981       };
72982     }
72983   }
72984
72985   jresult = result;
72986   return jresult;
72987 }
72988
72989
72990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72991   int jresult ;
72992   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72993   Dali::Toolkit::Ruler::RulerType result;
72994
72995   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72996   {
72997     try {
72998       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72999     } catch (std::out_of_range& e) {
73000       {
73001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73002       };
73003     } catch (std::exception& e) {
73004       {
73005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73006       };
73007     } catch (Dali::DaliException e) {
73008       {
73009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73010       };
73011     } catch (...) {
73012       {
73013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73014       };
73015     }
73016   }
73017
73018   jresult = (int)result;
73019   return jresult;
73020 }
73021
73022
73023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73024   unsigned int jresult ;
73025   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73026   bool result;
73027
73028   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73029   {
73030     try {
73031       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73032     } catch (std::out_of_range& e) {
73033       {
73034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73035       };
73036     } catch (std::exception& e) {
73037       {
73038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73039       };
73040     } catch (Dali::DaliException e) {
73041       {
73042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73043       };
73044     } catch (...) {
73045       {
73046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73047       };
73048     }
73049   }
73050
73051   jresult = result;
73052   return jresult;
73053 }
73054
73055
73056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73057   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73058
73059   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73060   {
73061     try {
73062       (arg1)->Enable();
73063     } catch (std::out_of_range& e) {
73064       {
73065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73066       };
73067     } catch (std::exception& e) {
73068       {
73069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73070       };
73071     } catch (Dali::DaliException e) {
73072       {
73073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73074       };
73075     } catch (...) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73078       };
73079     }
73080   }
73081
73082 }
73083
73084
73085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73086   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73087
73088   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73089   {
73090     try {
73091       (arg1)->Disable();
73092     } catch (std::out_of_range& e) {
73093       {
73094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73095       };
73096     } catch (std::exception& e) {
73097       {
73098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73099       };
73100     } catch (Dali::DaliException e) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73107       };
73108     }
73109   }
73110
73111 }
73112
73113
73114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73115   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73116   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73117   Dali::Toolkit::RulerDomain *argp2 ;
73118
73119   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73120   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73121   if (!argp2) {
73122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73123     return ;
73124   }
73125   arg2 = *argp2;
73126   {
73127     try {
73128       (arg1)->SetDomain(arg2);
73129     } catch (std::out_of_range& e) {
73130       {
73131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73132       };
73133     } catch (std::exception& e) {
73134       {
73135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73136       };
73137     } catch (Dali::DaliException e) {
73138       {
73139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73140       };
73141     } catch (...) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73144       };
73145     }
73146   }
73147
73148 }
73149
73150
73151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73152   void * jresult ;
73153   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73154   Dali::Toolkit::RulerDomain *result = 0 ;
73155
73156   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73157   {
73158     try {
73159       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73160     } catch (std::out_of_range& e) {
73161       {
73162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73163       };
73164     } catch (std::exception& e) {
73165       {
73166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73167       };
73168     } catch (Dali::DaliException e) {
73169       {
73170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73171       };
73172     } catch (...) {
73173       {
73174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73175       };
73176     }
73177   }
73178
73179   jresult = (void *)result;
73180   return jresult;
73181 }
73182
73183
73184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73185   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73186
73187   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73188   {
73189     try {
73190       (arg1)->DisableDomain();
73191     } catch (std::out_of_range& e) {
73192       {
73193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73194       };
73195     } catch (std::exception& e) {
73196       {
73197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73198       };
73199     } catch (Dali::DaliException e) {
73200       {
73201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73202       };
73203     } catch (...) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73206       };
73207     }
73208   }
73209
73210 }
73211
73212
73213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73214   float jresult ;
73215   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73216   float arg2 ;
73217   float arg3 ;
73218   float arg4 ;
73219   float result;
73220
73221   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73222   arg2 = (float)jarg2;
73223   arg3 = (float)jarg3;
73224   arg4 = (float)jarg4;
73225   {
73226     try {
73227       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73228     } catch (std::out_of_range& e) {
73229       {
73230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (std::exception& e) {
73233       {
73234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73235       };
73236     } catch (Dali::DaliException e) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73239       };
73240     } catch (...) {
73241       {
73242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73243       };
73244     }
73245   }
73246
73247   jresult = result;
73248   return jresult;
73249 }
73250
73251
73252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73253   float jresult ;
73254   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73255   float arg2 ;
73256   float arg3 ;
73257   float result;
73258
73259   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73260   arg2 = (float)jarg2;
73261   arg3 = (float)jarg3;
73262   {
73263     try {
73264       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73265     } catch (std::out_of_range& e) {
73266       {
73267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73268       };
73269     } catch (std::exception& e) {
73270       {
73271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73272       };
73273     } catch (Dali::DaliException e) {
73274       {
73275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73276       };
73277     } catch (...) {
73278       {
73279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73280       };
73281     }
73282   }
73283
73284   jresult = result;
73285   return jresult;
73286 }
73287
73288
73289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73290   float jresult ;
73291   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73292   float arg2 ;
73293   float result;
73294
73295   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73296   arg2 = (float)jarg2;
73297   {
73298     try {
73299       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73300     } catch (std::out_of_range& e) {
73301       {
73302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73303       };
73304     } catch (std::exception& e) {
73305       {
73306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73307       };
73308     } catch (Dali::DaliException e) {
73309       {
73310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73311       };
73312     } catch (...) {
73313       {
73314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73315       };
73316     }
73317   }
73318
73319   jresult = result;
73320   return jresult;
73321 }
73322
73323
73324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73325   float jresult ;
73326   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73327   float arg2 ;
73328   float arg3 ;
73329   float arg4 ;
73330   Dali::Toolkit::ClampState *arg5 = 0 ;
73331   float result;
73332
73333   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73334   arg2 = (float)jarg2;
73335   arg3 = (float)jarg3;
73336   arg4 = (float)jarg4;
73337   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73338   if (!arg5) {
73339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73340     return 0;
73341   }
73342   {
73343     try {
73344       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73345     } catch (std::out_of_range& e) {
73346       {
73347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73348       };
73349     } catch (std::exception& e) {
73350       {
73351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73352       };
73353     } catch (Dali::DaliException e) {
73354       {
73355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73356       };
73357     } catch (...) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73360       };
73361     }
73362   }
73363
73364   jresult = result;
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73370   float jresult ;
73371   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73372   float arg2 ;
73373   float arg3 ;
73374   float arg4 ;
73375   float arg5 ;
73376   float result;
73377
73378   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73379   arg2 = (float)jarg2;
73380   arg3 = (float)jarg3;
73381   arg4 = (float)jarg4;
73382   arg5 = (float)jarg5;
73383   {
73384     try {
73385       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73386     } catch (std::out_of_range& e) {
73387       {
73388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (std::exception& e) {
73391       {
73392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73393       };
73394     } catch (Dali::DaliException e) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73397       };
73398     } catch (...) {
73399       {
73400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73401       };
73402     }
73403   }
73404
73405   jresult = result;
73406   return jresult;
73407 }
73408
73409
73410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73411   float jresult ;
73412   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73413   float arg2 ;
73414   float arg3 ;
73415   float arg4 ;
73416   float result;
73417
73418   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73419   arg2 = (float)jarg2;
73420   arg3 = (float)jarg3;
73421   arg4 = (float)jarg4;
73422   {
73423     try {
73424       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73425     } catch (std::out_of_range& e) {
73426       {
73427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (std::exception& e) {
73430       {
73431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73432       };
73433     } catch (Dali::DaliException e) {
73434       {
73435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73436       };
73437     } catch (...) {
73438       {
73439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73440       };
73441     }
73442   }
73443
73444   jresult = result;
73445   return jresult;
73446 }
73447
73448
73449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73450   float jresult ;
73451   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73452   float arg2 ;
73453   float arg3 ;
73454   float result;
73455
73456   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73457   arg2 = (float)jarg2;
73458   arg3 = (float)jarg3;
73459   {
73460     try {
73461       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73462     } catch (std::out_of_range& e) {
73463       {
73464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73465       };
73466     } catch (std::exception& e) {
73467       {
73468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (Dali::DaliException e) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73473       };
73474     } catch (...) {
73475       {
73476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73477       };
73478     }
73479   }
73480
73481   jresult = result;
73482   return jresult;
73483 }
73484
73485
73486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73487   float jresult ;
73488   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73489   float arg2 ;
73490   float result;
73491
73492   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73493   arg2 = (float)jarg2;
73494   {
73495     try {
73496       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73497     } catch (std::out_of_range& e) {
73498       {
73499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73500       };
73501     } catch (std::exception& e) {
73502       {
73503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73504       };
73505     } catch (Dali::DaliException e) {
73506       {
73507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73508       };
73509     } catch (...) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73512       };
73513     }
73514   }
73515
73516   jresult = result;
73517   return jresult;
73518 }
73519
73520
73521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73522   float jresult ;
73523   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73524   float arg2 ;
73525   float arg3 ;
73526   float arg4 ;
73527   float arg5 ;
73528   Dali::Toolkit::ClampState *arg6 = 0 ;
73529   float result;
73530
73531   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73532   arg2 = (float)jarg2;
73533   arg3 = (float)jarg3;
73534   arg4 = (float)jarg4;
73535   arg5 = (float)jarg5;
73536   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73537   if (!arg6) {
73538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73539     return 0;
73540   }
73541   {
73542     try {
73543       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73544     } catch (std::out_of_range& e) {
73545       {
73546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73547       };
73548     } catch (std::exception& e) {
73549       {
73550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73551       };
73552     } catch (Dali::DaliException e) {
73553       {
73554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73555       };
73556     } catch (...) {
73557       {
73558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73559       };
73560     }
73561   }
73562
73563   jresult = result;
73564   return jresult;
73565 }
73566
73567
73568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73569   void * jresult ;
73570   Dali::Toolkit::DefaultRuler *result = 0 ;
73571
73572   {
73573     try {
73574       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73575     } catch (std::out_of_range& e) {
73576       {
73577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73578       };
73579     } catch (std::exception& e) {
73580       {
73581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73582       };
73583     } catch (Dali::DaliException e) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73586       };
73587     } catch (...) {
73588       {
73589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73590       };
73591     }
73592   }
73593
73594   jresult = (void *)result;
73595   return jresult;
73596 }
73597
73598
73599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73600   float jresult ;
73601   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73602   float arg2 ;
73603   float arg3 ;
73604   float result;
73605
73606   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73607   arg2 = (float)jarg2;
73608   arg3 = (float)jarg3;
73609   {
73610     try {
73611       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73612     } catch (std::out_of_range& e) {
73613       {
73614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73615       };
73616     } catch (std::exception& e) {
73617       {
73618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73619       };
73620     } catch (Dali::DaliException e) {
73621       {
73622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73623       };
73624     } catch (...) {
73625       {
73626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73627       };
73628     }
73629   }
73630
73631   jresult = result;
73632   return jresult;
73633 }
73634
73635
73636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73637   float jresult ;
73638   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73639   unsigned int arg2 ;
73640   unsigned int *arg3 = 0 ;
73641   bool arg4 ;
73642   float result;
73643
73644   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73645   arg2 = (unsigned int)jarg2;
73646   arg3 = (unsigned int *)jarg3;
73647   arg4 = jarg4 ? true : false;
73648   {
73649     try {
73650       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73651     } catch (std::out_of_range& e) {
73652       {
73653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73654       };
73655     } catch (std::exception& e) {
73656       {
73657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73658       };
73659     } catch (Dali::DaliException e) {
73660       {
73661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73662       };
73663     } catch (...) {
73664       {
73665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73666       };
73667     }
73668   }
73669
73670   jresult = result;
73671   return jresult;
73672 }
73673
73674
73675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73676   unsigned int jresult ;
73677   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73678   float arg2 ;
73679   bool arg3 ;
73680   unsigned int result;
73681
73682   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73683   arg2 = (float)jarg2;
73684   arg3 = jarg3 ? true : false;
73685   {
73686     try {
73687       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73688     } catch (std::out_of_range& e) {
73689       {
73690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73691       };
73692     } catch (std::exception& e) {
73693       {
73694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73695       };
73696     } catch (Dali::DaliException e) {
73697       {
73698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73699       };
73700     } catch (...) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73703       };
73704     }
73705   }
73706
73707   jresult = result;
73708   return jresult;
73709 }
73710
73711
73712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73713   unsigned int jresult ;
73714   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73715   unsigned int result;
73716
73717   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73718   {
73719     try {
73720       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73721     } catch (std::out_of_range& e) {
73722       {
73723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73724       };
73725     } catch (std::exception& e) {
73726       {
73727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73728       };
73729     } catch (Dali::DaliException e) {
73730       {
73731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73732       };
73733     } catch (...) {
73734       {
73735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73736       };
73737     }
73738   }
73739
73740   jresult = result;
73741   return jresult;
73742 }
73743
73744
73745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73746   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73747
73748   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73749   {
73750     try {
73751       delete arg1;
73752     } catch (std::out_of_range& e) {
73753       {
73754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73755       };
73756     } catch (std::exception& e) {
73757       {
73758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73759       };
73760     } catch (Dali::DaliException e) {
73761       {
73762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73763       };
73764     } catch (...) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73767       };
73768     }
73769   }
73770
73771 }
73772
73773
73774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73775   void * jresult ;
73776   float arg1 ;
73777   Dali::Toolkit::FixedRuler *result = 0 ;
73778
73779   arg1 = (float)jarg1;
73780   {
73781     try {
73782       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73783     } catch (std::out_of_range& e) {
73784       {
73785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73786       };
73787     } catch (std::exception& e) {
73788       {
73789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73790       };
73791     } catch (Dali::DaliException e) {
73792       {
73793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73794       };
73795     } catch (...) {
73796       {
73797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73798       };
73799     }
73800   }
73801
73802   jresult = (void *)result;
73803   return jresult;
73804 }
73805
73806
73807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73808   void * jresult ;
73809   Dali::Toolkit::FixedRuler *result = 0 ;
73810
73811   {
73812     try {
73813       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73814     } catch (std::out_of_range& e) {
73815       {
73816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73817       };
73818     } catch (std::exception& e) {
73819       {
73820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73821       };
73822     } catch (Dali::DaliException e) {
73823       {
73824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73825       };
73826     } catch (...) {
73827       {
73828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73829       };
73830     }
73831   }
73832
73833   jresult = (void *)result;
73834   return jresult;
73835 }
73836
73837
73838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73839   float jresult ;
73840   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73841   float arg2 ;
73842   float arg3 ;
73843   float result;
73844
73845   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73846   arg2 = (float)jarg2;
73847   arg3 = (float)jarg3;
73848   {
73849     try {
73850       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73851     } catch (std::out_of_range& e) {
73852       {
73853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73854       };
73855     } catch (std::exception& e) {
73856       {
73857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (Dali::DaliException e) {
73860       {
73861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73862       };
73863     } catch (...) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73866       };
73867     }
73868   }
73869
73870   jresult = result;
73871   return jresult;
73872 }
73873
73874
73875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73876   float jresult ;
73877   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73878   unsigned int arg2 ;
73879   unsigned int *arg3 = 0 ;
73880   bool arg4 ;
73881   float result;
73882
73883   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73884   arg2 = (unsigned int)jarg2;
73885   arg3 = (unsigned int *)jarg3;
73886   arg4 = jarg4 ? true : false;
73887   {
73888     try {
73889       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73890     } catch (std::out_of_range& e) {
73891       {
73892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73893       };
73894     } catch (std::exception& e) {
73895       {
73896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (Dali::DaliException e) {
73899       {
73900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73901       };
73902     } catch (...) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73905       };
73906     }
73907   }
73908
73909   jresult = result;
73910   return jresult;
73911 }
73912
73913
73914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73915   unsigned int jresult ;
73916   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73917   float arg2 ;
73918   bool arg3 ;
73919   unsigned int result;
73920
73921   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73922   arg2 = (float)jarg2;
73923   arg3 = jarg3 ? true : false;
73924   {
73925     try {
73926       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73927     } catch (std::out_of_range& e) {
73928       {
73929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73930       };
73931     } catch (std::exception& e) {
73932       {
73933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73934       };
73935     } catch (Dali::DaliException e) {
73936       {
73937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73938       };
73939     } catch (...) {
73940       {
73941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73942       };
73943     }
73944   }
73945
73946   jresult = result;
73947   return jresult;
73948 }
73949
73950
73951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73952   unsigned int jresult ;
73953   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73954   unsigned int result;
73955
73956   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73957   {
73958     try {
73959       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73960     } catch (std::out_of_range& e) {
73961       {
73962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73963       };
73964     } catch (std::exception& e) {
73965       {
73966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73967       };
73968     } catch (Dali::DaliException e) {
73969       {
73970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73971       };
73972     } catch (...) {
73973       {
73974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73975       };
73976     }
73977   }
73978
73979   jresult = result;
73980   return jresult;
73981 }
73982
73983
73984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73985   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73986
73987   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73988   {
73989     try {
73990       delete arg1;
73991     } catch (std::out_of_range& e) {
73992       {
73993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73994       };
73995     } catch (std::exception& e) {
73996       {
73997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73998       };
73999     } catch (Dali::DaliException e) {
74000       {
74001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74002       };
74003     } catch (...) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74006       };
74007     }
74008   }
74009
74010 }
74011
74012
74013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74014   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74015   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74016
74017   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74018   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74019   if (arg1) (arg1)->scale = *arg2;
74020 }
74021
74022
74023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74024   void * jresult ;
74025   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74026   Dali::Toolkit::ClampState2D *result = 0 ;
74027
74028   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74029   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74030   jresult = (void *)result;
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74036   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74037   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74038
74039   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74040   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74041   if (arg1) (arg1)->position = *arg2;
74042 }
74043
74044
74045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74046   void * jresult ;
74047   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74048   Dali::Toolkit::ClampState2D *result = 0 ;
74049
74050   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74051   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74052   jresult = (void *)result;
74053   return jresult;
74054 }
74055
74056
74057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74058   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74059   Dali::Toolkit::ClampState arg2 ;
74060
74061   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74062   arg2 = (Dali::Toolkit::ClampState)jarg2;
74063   if (arg1) (arg1)->rotation = arg2;
74064 }
74065
74066
74067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74068   int jresult ;
74069   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74070   Dali::Toolkit::ClampState result;
74071
74072   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74073   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74074   jresult = (int)result;
74075   return jresult;
74076 }
74077
74078
74079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74080   void * jresult ;
74081   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74082
74083   {
74084     try {
74085       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74086     } catch (std::out_of_range& e) {
74087       {
74088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74089       };
74090     } catch (std::exception& e) {
74091       {
74092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74093       };
74094     } catch (Dali::DaliException e) {
74095       {
74096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74097       };
74098     } catch (...) {
74099       {
74100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74101       };
74102     }
74103   }
74104
74105   jresult = (void *)result;
74106   return jresult;
74107 }
74108
74109
74110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74111   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74112
74113   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74114   {
74115     try {
74116       delete arg1;
74117     } catch (std::out_of_range& e) {
74118       {
74119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74120       };
74121     } catch (std::exception& e) {
74122       {
74123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74124       };
74125     } catch (Dali::DaliException e) {
74126       {
74127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74132       };
74133     }
74134   }
74135
74136 }
74137
74138
74139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74140   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74141   Dali::Toolkit::SnapType arg2 ;
74142
74143   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74144   arg2 = (Dali::Toolkit::SnapType)jarg2;
74145   if (arg1) (arg1)->type = arg2;
74146 }
74147
74148
74149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74150   int jresult ;
74151   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74152   Dali::Toolkit::SnapType result;
74153
74154   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74155   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74156   jresult = (int)result;
74157   return jresult;
74158 }
74159
74160
74161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74162   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74164
74165   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74166   arg2 = (Dali::Vector2 *)jarg2;
74167   if (arg1) (arg1)->position = *arg2;
74168 }
74169
74170
74171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74172   void * jresult ;
74173   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74174   Dali::Vector2 *result = 0 ;
74175
74176   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74177   result = (Dali::Vector2 *)& ((arg1)->position);
74178   jresult = (void *)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74184   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74185   float arg2 ;
74186
74187   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74188   arg2 = (float)jarg2;
74189   if (arg1) (arg1)->duration = arg2;
74190 }
74191
74192
74193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74194   float jresult ;
74195   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74196   float result;
74197
74198   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74199   result = (float) ((arg1)->duration);
74200   jresult = result;
74201   return jresult;
74202 }
74203
74204
74205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74206   void * jresult ;
74207   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74208
74209   {
74210     try {
74211       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74212     } catch (std::out_of_range& e) {
74213       {
74214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (std::exception& e) {
74217       {
74218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74219       };
74220     } catch (Dali::DaliException e) {
74221       {
74222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74223       };
74224     } catch (...) {
74225       {
74226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74227       };
74228     }
74229   }
74230
74231   jresult = (void *)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74237   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74238
74239   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74240   {
74241     try {
74242       delete arg1;
74243     } catch (std::out_of_range& e) {
74244       {
74245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74246       };
74247     } catch (std::exception& e) {
74248       {
74249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74250       };
74251     } catch (Dali::DaliException e) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74254       };
74255     } catch (...) {
74256       {
74257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74258       };
74259     }
74260   }
74261
74262 }
74263
74264
74265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74266   int jresult ;
74267   int result;
74268
74269   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74270   jresult = (int)result;
74271   return jresult;
74272 }
74273
74274
74275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74276   int jresult ;
74277   int result;
74278
74279   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74280   jresult = (int)result;
74281   return jresult;
74282 }
74283
74284
74285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74286   int jresult ;
74287   int result;
74288
74289   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74290   jresult = (int)result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74296   int jresult ;
74297   int result;
74298
74299   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74300   jresult = (int)result;
74301   return jresult;
74302 }
74303
74304
74305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74306   int jresult ;
74307   int result;
74308
74309   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74310   jresult = (int)result;
74311   return jresult;
74312 }
74313
74314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74315   int jresult ;
74316   int result;
74317
74318   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74319   jresult = (int)result;
74320   return jresult;
74321 }
74322
74323
74324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74325   int jresult ;
74326   int result;
74327
74328   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74329   jresult = (int)result;
74330   return jresult;
74331 }
74332
74333
74334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74335   int jresult ;
74336   int result;
74337
74338   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74339   jresult = (int)result;
74340   return jresult;
74341 }
74342
74343
74344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74345   int jresult ;
74346   int result;
74347
74348   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74349   jresult = (int)result;
74350   return jresult;
74351 }
74352
74353
74354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74355   int jresult ;
74356   int result;
74357
74358   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74359   jresult = (int)result;
74360   return jresult;
74361 }
74362
74363
74364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74365   int jresult ;
74366   int result;
74367
74368   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74369   jresult = (int)result;
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74375   int jresult ;
74376   int result;
74377
74378   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74379   jresult = (int)result;
74380   return jresult;
74381 }
74382
74383
74384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74385   int jresult ;
74386   int result;
74387
74388   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74389   jresult = (int)result;
74390   return jresult;
74391 }
74392
74393
74394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74395   int jresult ;
74396   int result;
74397
74398   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74399   jresult = (int)result;
74400   return jresult;
74401 }
74402
74403
74404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74405   int jresult ;
74406   int result;
74407
74408   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74409   jresult = (int)result;
74410   return jresult;
74411 }
74412
74413
74414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74415   int jresult ;
74416   int result;
74417
74418   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74419   jresult = (int)result;
74420   return jresult;
74421 }
74422
74423
74424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74425   int jresult ;
74426   int result;
74427
74428   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74429   jresult = (int)result;
74430   return jresult;
74431 }
74432
74433
74434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74435   int jresult ;
74436   int result;
74437
74438   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74439   jresult = (int)result;
74440   return jresult;
74441 }
74442
74443
74444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74445   int jresult ;
74446   int result;
74447
74448   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74449   jresult = (int)result;
74450   return jresult;
74451 }
74452
74453
74454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74455   int jresult ;
74456   int result;
74457
74458   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74459   jresult = (int)result;
74460   return jresult;
74461 }
74462
74463
74464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74465   int jresult ;
74466   int result;
74467
74468   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74469   jresult = (int)result;
74470   return jresult;
74471 }
74472
74473
74474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74475   int jresult ;
74476   int result;
74477
74478   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74479   jresult = (int)result;
74480   return jresult;
74481 }
74482
74483
74484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74485   int jresult ;
74486   int result;
74487
74488   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74489   jresult = (int)result;
74490   return jresult;
74491 }
74492
74493
74494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74495   int jresult ;
74496   int result;
74497
74498   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74499   jresult = (int)result;
74500   return jresult;
74501 }
74502
74503
74504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74505   int jresult ;
74506   int result;
74507
74508   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74509   jresult = (int)result;
74510   return jresult;
74511 }
74512
74513
74514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74515   int jresult ;
74516   int result;
74517
74518   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74519   jresult = (int)result;
74520   return jresult;
74521 }
74522
74523
74524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74525   void * jresult ;
74526   Dali::Toolkit::ScrollView::Property *result = 0 ;
74527
74528   {
74529     try {
74530       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74531     } catch (std::out_of_range& e) {
74532       {
74533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74534       };
74535     } catch (std::exception& e) {
74536       {
74537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74538       };
74539     } catch (Dali::DaliException e) {
74540       {
74541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74542       };
74543     } catch (...) {
74544       {
74545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74546       };
74547     }
74548   }
74549
74550   jresult = (void *)result;
74551   return jresult;
74552 }
74553
74554
74555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74556   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74557
74558   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74559   {
74560     try {
74561       delete arg1;
74562     } catch (std::out_of_range& e) {
74563       {
74564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74565       };
74566     } catch (std::exception& e) {
74567       {
74568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74569       };
74570     } catch (Dali::DaliException e) {
74571       {
74572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74573       };
74574     } catch (...) {
74575       {
74576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74577       };
74578     }
74579   }
74580
74581 }
74582
74583
74584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74585   void * jresult ;
74586   Dali::Toolkit::ScrollView *result = 0 ;
74587
74588   {
74589     try {
74590       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74591     } catch (std::out_of_range& e) {
74592       {
74593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74594       };
74595     } catch (std::exception& e) {
74596       {
74597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74598       };
74599     } catch (Dali::DaliException e) {
74600       {
74601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74602       };
74603     } catch (...) {
74604       {
74605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74606       };
74607     }
74608   }
74609
74610   jresult = (void *)result;
74611   return jresult;
74612 }
74613
74614
74615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74616   void * jresult ;
74617   Dali::Toolkit::ScrollView *arg1 = 0 ;
74618   Dali::Toolkit::ScrollView *result = 0 ;
74619
74620   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74621   if (!arg1) {
74622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74623     return 0;
74624   }
74625   {
74626     try {
74627       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74628     } catch (std::out_of_range& e) {
74629       {
74630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74631       };
74632     } catch (std::exception& e) {
74633       {
74634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74635       };
74636     } catch (Dali::DaliException e) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74639       };
74640     } catch (...) {
74641       {
74642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74643       };
74644     }
74645   }
74646
74647   jresult = (void *)result;
74648   return jresult;
74649 }
74650
74651
74652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74653   void * jresult ;
74654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74655   Dali::Toolkit::ScrollView *arg2 = 0 ;
74656   Dali::Toolkit::ScrollView *result = 0 ;
74657
74658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74659   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74660   if (!arg2) {
74661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74662     return 0;
74663   }
74664   {
74665     try {
74666       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74667     } catch (std::out_of_range& e) {
74668       {
74669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74670       };
74671     } catch (std::exception& e) {
74672       {
74673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74674       };
74675     } catch (Dali::DaliException e) {
74676       {
74677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74678       };
74679     } catch (...) {
74680       {
74681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74682       };
74683     }
74684   }
74685
74686   jresult = (void *)result;
74687   return jresult;
74688 }
74689
74690
74691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74693
74694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74695   {
74696     try {
74697       delete arg1;
74698     } catch (std::out_of_range& e) {
74699       {
74700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74701       };
74702     } catch (std::exception& e) {
74703       {
74704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74705       };
74706     } catch (Dali::DaliException e) {
74707       {
74708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74709       };
74710     } catch (...) {
74711       {
74712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74713       };
74714     }
74715   }
74716
74717 }
74718
74719
74720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74721   void * jresult ;
74722   Dali::Toolkit::ScrollView result;
74723
74724   {
74725     try {
74726       result = Dali::Toolkit::ScrollView::New();
74727     } catch (std::out_of_range& e) {
74728       {
74729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74730       };
74731     } catch (std::exception& e) {
74732       {
74733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74734       };
74735     } catch (Dali::DaliException e) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74738       };
74739     } catch (...) {
74740       {
74741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74742       };
74743     }
74744   }
74745
74746   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74747   return jresult;
74748 }
74749
74750
74751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74752   void * jresult ;
74753   Dali::BaseHandle arg1 ;
74754   Dali::BaseHandle *argp1 ;
74755   Dali::Toolkit::ScrollView result;
74756
74757   argp1 = (Dali::BaseHandle *)jarg1;
74758   if (!argp1) {
74759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74760     return 0;
74761   }
74762   arg1 = *argp1;
74763   {
74764     try {
74765       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74766     } catch (std::out_of_range& e) {
74767       {
74768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74769       };
74770     } catch (std::exception& e) {
74771       {
74772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74773       };
74774     } catch (Dali::DaliException e) {
74775       {
74776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74777       };
74778     } catch (...) {
74779       {
74780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74781       };
74782     }
74783   }
74784
74785   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74786   return jresult;
74787 }
74788
74789
74790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74791   void * jresult ;
74792   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74793   Dali::AlphaFunction result;
74794
74795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74796   {
74797     try {
74798       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74799     } catch (std::out_of_range& e) {
74800       {
74801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74802       };
74803     } catch (std::exception& e) {
74804       {
74805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74806       };
74807     } catch (Dali::DaliException e) {
74808       {
74809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74810       };
74811     } catch (...) {
74812       {
74813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74814       };
74815     }
74816   }
74817
74818   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74819   return jresult;
74820 }
74821
74822
74823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74824   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74825   Dali::AlphaFunction arg2 ;
74826   Dali::AlphaFunction *argp2 ;
74827
74828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74829   argp2 = (Dali::AlphaFunction *)jarg2;
74830   if (!argp2) {
74831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74832     return ;
74833   }
74834   arg2 = *argp2;
74835   {
74836     try {
74837       (arg1)->SetScrollSnapAlphaFunction(arg2);
74838     } catch (std::out_of_range& e) {
74839       {
74840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74841       };
74842     } catch (std::exception& e) {
74843       {
74844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74845       };
74846     } catch (Dali::DaliException e) {
74847       {
74848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74849       };
74850     } catch (...) {
74851       {
74852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74853       };
74854     }
74855   }
74856
74857 }
74858
74859
74860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74861   void * jresult ;
74862   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74863   Dali::AlphaFunction result;
74864
74865   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74866   {
74867     try {
74868       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74869     } catch (std::out_of_range& e) {
74870       {
74871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74872       };
74873     } catch (std::exception& e) {
74874       {
74875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74876       };
74877     } catch (Dali::DaliException e) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74884       };
74885     }
74886   }
74887
74888   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74889   return jresult;
74890 }
74891
74892
74893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74895   Dali::AlphaFunction arg2 ;
74896   Dali::AlphaFunction *argp2 ;
74897
74898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74899   argp2 = (Dali::AlphaFunction *)jarg2;
74900   if (!argp2) {
74901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74902     return ;
74903   }
74904   arg2 = *argp2;
74905   {
74906     try {
74907       (arg1)->SetScrollFlickAlphaFunction(arg2);
74908     } catch (std::out_of_range& e) {
74909       {
74910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74911       };
74912     } catch (std::exception& e) {
74913       {
74914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74915       };
74916     } catch (Dali::DaliException e) {
74917       {
74918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74919       };
74920     } catch (...) {
74921       {
74922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74923       };
74924     }
74925   }
74926
74927 }
74928
74929
74930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74931   float jresult ;
74932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74933   float result;
74934
74935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74936   {
74937     try {
74938       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
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 = result;
74959   return jresult;
74960 }
74961
74962
74963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74965   float arg2 ;
74966
74967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74968   arg2 = (float)jarg2;
74969   {
74970     try {
74971       (arg1)->SetScrollSnapDuration(arg2);
74972     } catch (std::out_of_range& e) {
74973       {
74974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74975       };
74976     } catch (std::exception& e) {
74977       {
74978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74979       };
74980     } catch (Dali::DaliException e) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74983       };
74984     } catch (...) {
74985       {
74986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74987       };
74988     }
74989   }
74990
74991 }
74992
74993
74994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74995   float jresult ;
74996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74997   float result;
74998
74999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75000   {
75001     try {
75002       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75003     } catch (std::out_of_range& e) {
75004       {
75005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75006       };
75007     } catch (std::exception& e) {
75008       {
75009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75010       };
75011     } catch (Dali::DaliException e) {
75012       {
75013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75014       };
75015     } catch (...) {
75016       {
75017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75018       };
75019     }
75020   }
75021
75022   jresult = result;
75023   return jresult;
75024 }
75025
75026
75027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75029   float arg2 ;
75030
75031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75032   arg2 = (float)jarg2;
75033   {
75034     try {
75035       (arg1)->SetScrollFlickDuration(arg2);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75051       };
75052     }
75053   }
75054
75055 }
75056
75057
75058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75060   Dali::Toolkit::RulerPtr arg2 ;
75061   Dali::Toolkit::RulerPtr *argp2 ;
75062
75063   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75064   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75065   if (!argp2) {
75066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75067     return ;
75068   }
75069   arg2 = *argp2;
75070   {
75071     try {
75072       (arg1)->SetRulerX(arg2);
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (Dali::DaliException e) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75084       };
75085     } catch (...) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75088       };
75089     }
75090   }
75091
75092 }
75093
75094
75095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75097   Dali::Toolkit::RulerPtr arg2 ;
75098   Dali::Toolkit::RulerPtr *argp2 ;
75099
75100   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75101   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75102   if (!argp2) {
75103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75104     return ;
75105   }
75106   arg2 = *argp2;
75107   {
75108     try {
75109       (arg1)->SetRulerY(arg2);
75110     } catch (std::out_of_range& e) {
75111       {
75112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75113       };
75114     } catch (std::exception& e) {
75115       {
75116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75117       };
75118     } catch (Dali::DaliException e) {
75119       {
75120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75121       };
75122     } catch (...) {
75123       {
75124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75125       };
75126     }
75127   }
75128
75129 }
75130
75131
75132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75134   bool arg2 ;
75135
75136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75137   arg2 = jarg2 ? true : false;
75138   {
75139     try {
75140       (arg1)->SetScrollSensitive(arg2);
75141     } catch (std::out_of_range& e) {
75142       {
75143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75144       };
75145     } catch (std::exception& e) {
75146       {
75147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75148       };
75149     } catch (Dali::DaliException e) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75152       };
75153     } catch (...) {
75154       {
75155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75156       };
75157     }
75158   }
75159
75160 }
75161
75162
75163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75165   float arg2 ;
75166   float arg3 ;
75167
75168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75169   arg2 = (float)jarg2;
75170   arg3 = (float)jarg3;
75171   {
75172     try {
75173       (arg1)->SetMaxOvershoot(arg2,arg3);
75174     } catch (std::out_of_range& e) {
75175       {
75176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75177       };
75178     } catch (std::exception& e) {
75179       {
75180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75181       };
75182     } catch (Dali::DaliException e) {
75183       {
75184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75185       };
75186     } catch (...) {
75187       {
75188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75189       };
75190     }
75191   }
75192
75193 }
75194
75195
75196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75198   Dali::AlphaFunction arg2 ;
75199   Dali::AlphaFunction *argp2 ;
75200
75201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75202   argp2 = (Dali::AlphaFunction *)jarg2;
75203   if (!argp2) {
75204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75205     return ;
75206   }
75207   arg2 = *argp2;
75208   {
75209     try {
75210       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75226       };
75227     }
75228   }
75229
75230 }
75231
75232
75233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75235   float arg2 ;
75236
75237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75238   arg2 = (float)jarg2;
75239   {
75240     try {
75241       (arg1)->SetSnapOvershootDuration(arg2);
75242     } catch (std::out_of_range& e) {
75243       {
75244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75245       };
75246     } catch (std::exception& e) {
75247       {
75248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75249       };
75250     } catch (Dali::DaliException e) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75257       };
75258     }
75259   }
75260
75261 }
75262
75263
75264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75266   bool arg2 ;
75267
75268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75269   arg2 = jarg2 ? true : false;
75270   {
75271     try {
75272       (arg1)->SetActorAutoSnap(arg2);
75273     } catch (std::out_of_range& e) {
75274       {
75275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75276       };
75277     } catch (std::exception& e) {
75278       {
75279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75280       };
75281     } catch (Dali::DaliException e) {
75282       {
75283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75284       };
75285     } catch (...) {
75286       {
75287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75288       };
75289     }
75290   }
75291
75292 }
75293
75294
75295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75296   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75297   bool arg2 ;
75298
75299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75300   arg2 = jarg2 ? true : false;
75301   {
75302     try {
75303       (arg1)->SetWrapMode(arg2);
75304     } catch (std::out_of_range& e) {
75305       {
75306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75307       };
75308     } catch (std::exception& e) {
75309       {
75310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75311       };
75312     } catch (Dali::DaliException e) {
75313       {
75314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75315       };
75316     } catch (...) {
75317       {
75318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75319       };
75320     }
75321   }
75322
75323 }
75324
75325
75326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75327   int jresult ;
75328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75329   int result;
75330
75331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75332   {
75333     try {
75334       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75342       };
75343     } catch (Dali::DaliException e) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75346       };
75347     } catch (...) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75350       };
75351     }
75352   }
75353
75354   jresult = result;
75355   return jresult;
75356 }
75357
75358
75359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75361   int arg2 ;
75362
75363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75364   arg2 = (int)jarg2;
75365   {
75366     try {
75367       (arg1)->SetScrollUpdateDistance(arg2);
75368     } catch (std::out_of_range& e) {
75369       {
75370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75371       };
75372     } catch (std::exception& e) {
75373       {
75374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75375       };
75376     } catch (Dali::DaliException e) {
75377       {
75378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75379       };
75380     } catch (...) {
75381       {
75382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75383       };
75384     }
75385   }
75386
75387 }
75388
75389
75390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75391   unsigned int jresult ;
75392   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75393   bool result;
75394
75395   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75396   {
75397     try {
75398       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75399     } catch (std::out_of_range& e) {
75400       {
75401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75402       };
75403     } catch (std::exception& e) {
75404       {
75405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75406       };
75407     } catch (Dali::DaliException e) {
75408       {
75409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75410       };
75411     } catch (...) {
75412       {
75413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75414       };
75415     }
75416   }
75417
75418   jresult = result;
75419   return jresult;
75420 }
75421
75422
75423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75425   bool arg2 ;
75426
75427   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75428   arg2 = jarg2 ? true : false;
75429   {
75430     try {
75431       (arg1)->SetAxisAutoLock(arg2);
75432     } catch (std::out_of_range& e) {
75433       {
75434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75435       };
75436     } catch (std::exception& e) {
75437       {
75438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75439       };
75440     } catch (Dali::DaliException e) {
75441       {
75442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75443       };
75444     } catch (...) {
75445       {
75446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75447       };
75448     }
75449   }
75450
75451 }
75452
75453
75454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75455   float jresult ;
75456   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75457   float result;
75458
75459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75460   {
75461     try {
75462       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75463     } catch (std::out_of_range& e) {
75464       {
75465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75466       };
75467     } catch (std::exception& e) {
75468       {
75469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75470       };
75471     } catch (Dali::DaliException e) {
75472       {
75473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75478       };
75479     }
75480   }
75481
75482   jresult = result;
75483   return jresult;
75484 }
75485
75486
75487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75489   float arg2 ;
75490
75491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75492   arg2 = (float)jarg2;
75493   {
75494     try {
75495       (arg1)->SetAxisAutoLockGradient(arg2);
75496     } catch (std::out_of_range& e) {
75497       {
75498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75499       };
75500     } catch (std::exception& e) {
75501       {
75502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75503       };
75504     } catch (Dali::DaliException e) {
75505       {
75506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75507       };
75508     } catch (...) {
75509       {
75510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75511       };
75512     }
75513   }
75514
75515 }
75516
75517
75518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75519   float jresult ;
75520   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75521   float result;
75522
75523   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75524   {
75525     try {
75526       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75527     } catch (std::out_of_range& e) {
75528       {
75529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75530       };
75531     } catch (std::exception& e) {
75532       {
75533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75534       };
75535     } catch (Dali::DaliException e) {
75536       {
75537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75538       };
75539     } catch (...) {
75540       {
75541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75542       };
75543     }
75544   }
75545
75546   jresult = result;
75547   return jresult;
75548 }
75549
75550
75551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75552   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75553   float arg2 ;
75554
75555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75556   arg2 = (float)jarg2;
75557   {
75558     try {
75559       (arg1)->SetFrictionCoefficient(arg2);
75560     } catch (std::out_of_range& e) {
75561       {
75562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75563       };
75564     } catch (std::exception& e) {
75565       {
75566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75567       };
75568     } catch (Dali::DaliException e) {
75569       {
75570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75571       };
75572     } catch (...) {
75573       {
75574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75575       };
75576     }
75577   }
75578
75579 }
75580
75581
75582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75583   float jresult ;
75584   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75585   float result;
75586
75587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75588   {
75589     try {
75590       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75591     } catch (std::out_of_range& e) {
75592       {
75593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75594       };
75595     } catch (std::exception& e) {
75596       {
75597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (Dali::DaliException e) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75602       };
75603     } catch (...) {
75604       {
75605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75606       };
75607     }
75608   }
75609
75610   jresult = result;
75611   return jresult;
75612 }
75613
75614
75615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75616   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75617   float arg2 ;
75618
75619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75620   arg2 = (float)jarg2;
75621   {
75622     try {
75623       (arg1)->SetFlickSpeedCoefficient(arg2);
75624     } catch (std::out_of_range& e) {
75625       {
75626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (std::exception& e) {
75629       {
75630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75631       };
75632     } catch (Dali::DaliException e) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75635       };
75636     } catch (...) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75639       };
75640     }
75641   }
75642
75643 }
75644
75645
75646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75647   void * jresult ;
75648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75649   Dali::Vector2 result;
75650
75651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75652   {
75653     try {
75654       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75655     } catch (std::out_of_range& e) {
75656       {
75657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75658       };
75659     } catch (std::exception& e) {
75660       {
75661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75662       };
75663     } catch (Dali::DaliException e) {
75664       {
75665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75666       };
75667     } catch (...) {
75668       {
75669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75670       };
75671     }
75672   }
75673
75674   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75675   return jresult;
75676 }
75677
75678
75679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75680   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75681   Dali::Vector2 *arg2 = 0 ;
75682
75683   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75684   arg2 = (Dali::Vector2 *)jarg2;
75685   if (!arg2) {
75686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75687     return ;
75688   }
75689   {
75690     try {
75691       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75692     } catch (std::out_of_range& e) {
75693       {
75694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75695       };
75696     } catch (std::exception& e) {
75697       {
75698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75699       };
75700     } catch (Dali::DaliException e) {
75701       {
75702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75703       };
75704     } catch (...) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75707       };
75708     }
75709   }
75710
75711 }
75712
75713
75714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75715   float jresult ;
75716   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75717   float result;
75718
75719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75720   {
75721     try {
75722       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75723     } catch (std::out_of_range& e) {
75724       {
75725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75726       };
75727     } catch (std::exception& e) {
75728       {
75729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75730       };
75731     } catch (Dali::DaliException e) {
75732       {
75733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75734       };
75735     } catch (...) {
75736       {
75737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75738       };
75739     }
75740   }
75741
75742   jresult = result;
75743   return jresult;
75744 }
75745
75746
75747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75749   float arg2 ;
75750
75751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75752   arg2 = (float)jarg2;
75753   {
75754     try {
75755       (arg1)->SetMinimumSpeedForFlick(arg2);
75756     } catch (std::out_of_range& e) {
75757       {
75758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75759       };
75760     } catch (std::exception& e) {
75761       {
75762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75763       };
75764     } catch (Dali::DaliException e) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75767       };
75768     } catch (...) {
75769       {
75770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75771       };
75772     }
75773   }
75774
75775 }
75776
75777
75778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75779   float jresult ;
75780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75781   float result;
75782
75783   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75784   {
75785     try {
75786       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75787     } catch (std::out_of_range& e) {
75788       {
75789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (std::exception& e) {
75792       {
75793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (Dali::DaliException e) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75798       };
75799     } catch (...) {
75800       {
75801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75802       };
75803     }
75804   }
75805
75806   jresult = result;
75807   return jresult;
75808 }
75809
75810
75811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75813   float arg2 ;
75814
75815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75816   arg2 = (float)jarg2;
75817   {
75818     try {
75819       (arg1)->SetMaxFlickSpeed(arg2);
75820     } catch (std::out_of_range& e) {
75821       {
75822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75823       };
75824     } catch (std::exception& e) {
75825       {
75826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75827       };
75828     } catch (Dali::DaliException e) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75831       };
75832     } catch (...) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75835       };
75836     }
75837   }
75838
75839 }
75840
75841
75842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75843   void * jresult ;
75844   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75845   Dali::Vector2 result;
75846
75847   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75848   {
75849     try {
75850       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75851     } catch (std::out_of_range& e) {
75852       {
75853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75854       };
75855     } catch (std::exception& e) {
75856       {
75857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75858       };
75859     } catch (Dali::DaliException e) {
75860       {
75861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75862       };
75863     } catch (...) {
75864       {
75865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75866       };
75867     }
75868   }
75869
75870   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75871   return jresult;
75872 }
75873
75874
75875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75877   Dali::Vector2 arg2 ;
75878   Dali::Vector2 *argp2 ;
75879
75880   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75881   argp2 = (Dali::Vector2 *)jarg2;
75882   if (!argp2) {
75883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75884     return ;
75885   }
75886   arg2 = *argp2;
75887   {
75888     try {
75889       (arg1)->SetWheelScrollDistanceStep(arg2);
75890     } catch (std::out_of_range& e) {
75891       {
75892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75893       };
75894     } catch (std::exception& e) {
75895       {
75896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75897       };
75898     } catch (Dali::DaliException e) {
75899       {
75900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75901       };
75902     } catch (...) {
75903       {
75904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75905       };
75906     }
75907   }
75908
75909 }
75910
75911
75912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75913   void * jresult ;
75914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75915   Dali::Vector2 result;
75916
75917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75918   {
75919     try {
75920       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75921     } catch (std::out_of_range& e) {
75922       {
75923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75924       };
75925     } catch (std::exception& e) {
75926       {
75927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75928       };
75929     } catch (Dali::DaliException e) {
75930       {
75931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75932       };
75933     } catch (...) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75936       };
75937     }
75938   }
75939
75940   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75941   return jresult;
75942 }
75943
75944
75945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75946   unsigned int jresult ;
75947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75948   unsigned int result;
75949
75950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75951   {
75952     try {
75953       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75954     } catch (std::out_of_range& e) {
75955       {
75956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75957       };
75958     } catch (std::exception& e) {
75959       {
75960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75961       };
75962     } catch (Dali::DaliException e) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75965       };
75966     } catch (...) {
75967       {
75968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75969       };
75970     }
75971   }
75972
75973   jresult = result;
75974   return jresult;
75975 }
75976
75977
75978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75979   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75980   Dali::Vector2 *arg2 = 0 ;
75981
75982   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75983   arg2 = (Dali::Vector2 *)jarg2;
75984   if (!arg2) {
75985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75986     return ;
75987   }
75988   {
75989     try {
75990       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75991     } catch (std::out_of_range& e) {
75992       {
75993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75994       };
75995     } catch (std::exception& e) {
75996       {
75997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75998       };
75999     } catch (Dali::DaliException e) {
76000       {
76001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76002       };
76003     } catch (...) {
76004       {
76005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76006       };
76007     }
76008   }
76009
76010 }
76011
76012
76013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76015   Dali::Vector2 *arg2 = 0 ;
76016   float arg3 ;
76017
76018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76019   arg2 = (Dali::Vector2 *)jarg2;
76020   if (!arg2) {
76021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76022     return ;
76023   }
76024   arg3 = (float)jarg3;
76025   {
76026     try {
76027       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76028     } catch (std::out_of_range& e) {
76029       {
76030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76031       };
76032     } catch (std::exception& e) {
76033       {
76034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76035       };
76036     } catch (Dali::DaliException e) {
76037       {
76038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76039       };
76040     } catch (...) {
76041       {
76042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76043       };
76044     }
76045   }
76046
76047 }
76048
76049
76050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76052   Dali::Vector2 *arg2 = 0 ;
76053   float arg3 ;
76054   Dali::AlphaFunction arg4 ;
76055   Dali::AlphaFunction *argp4 ;
76056
76057   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76058   arg2 = (Dali::Vector2 *)jarg2;
76059   if (!arg2) {
76060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76061     return ;
76062   }
76063   arg3 = (float)jarg3;
76064   argp4 = (Dali::AlphaFunction *)jarg4;
76065   if (!argp4) {
76066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76067     return ;
76068   }
76069   arg4 = *argp4;
76070   {
76071     try {
76072       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76073     } catch (std::out_of_range& e) {
76074       {
76075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76076       };
76077     } catch (std::exception& e) {
76078       {
76079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76080       };
76081     } catch (Dali::DaliException e) {
76082       {
76083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76084       };
76085     } catch (...) {
76086       {
76087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76088       };
76089     }
76090   }
76091
76092 }
76093
76094
76095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76097   Dali::Vector2 *arg2 = 0 ;
76098   float arg3 ;
76099   Dali::Toolkit::DirectionBias arg4 ;
76100   Dali::Toolkit::DirectionBias arg5 ;
76101
76102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76103   arg2 = (Dali::Vector2 *)jarg2;
76104   if (!arg2) {
76105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76106     return ;
76107   }
76108   arg3 = (float)jarg3;
76109   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76110   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76111   {
76112     try {
76113       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76114     } catch (std::out_of_range& e) {
76115       {
76116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76117       };
76118     } catch (std::exception& e) {
76119       {
76120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76121       };
76122     } catch (Dali::DaliException e) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76125       };
76126     } catch (...) {
76127       {
76128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76129       };
76130     }
76131   }
76132
76133 }
76134
76135
76136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76138   Dali::Vector2 *arg2 = 0 ;
76139   float arg3 ;
76140   Dali::AlphaFunction arg4 ;
76141   Dali::Toolkit::DirectionBias arg5 ;
76142   Dali::Toolkit::DirectionBias arg6 ;
76143   Dali::AlphaFunction *argp4 ;
76144
76145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76146   arg2 = (Dali::Vector2 *)jarg2;
76147   if (!arg2) {
76148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76149     return ;
76150   }
76151   arg3 = (float)jarg3;
76152   argp4 = (Dali::AlphaFunction *)jarg4;
76153   if (!argp4) {
76154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76155     return ;
76156   }
76157   arg4 = *argp4;
76158   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76159   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76160   {
76161     try {
76162       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76163     } catch (std::out_of_range& e) {
76164       {
76165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76166       };
76167     } catch (std::exception& e) {
76168       {
76169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76170       };
76171     } catch (Dali::DaliException e) {
76172       {
76173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76174       };
76175     } catch (...) {
76176       {
76177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76178       };
76179     }
76180   }
76181
76182 }
76183
76184
76185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76187   unsigned int arg2 ;
76188
76189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76190   arg2 = (unsigned int)jarg2;
76191   {
76192     try {
76193       (arg1)->ScrollTo(arg2);
76194     } catch (std::out_of_range& e) {
76195       {
76196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76197       };
76198     } catch (std::exception& e) {
76199       {
76200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76201       };
76202     } catch (Dali::DaliException e) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76205       };
76206     } catch (...) {
76207       {
76208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76209       };
76210     }
76211   }
76212
76213 }
76214
76215
76216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76218   unsigned int arg2 ;
76219   float arg3 ;
76220
76221   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76222   arg2 = (unsigned int)jarg2;
76223   arg3 = (float)jarg3;
76224   {
76225     try {
76226       (arg1)->ScrollTo(arg2,arg3);
76227     } catch (std::out_of_range& e) {
76228       {
76229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76230       };
76231     } catch (std::exception& e) {
76232       {
76233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76234       };
76235     } catch (Dali::DaliException e) {
76236       {
76237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76238       };
76239     } catch (...) {
76240       {
76241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76242       };
76243     }
76244   }
76245
76246 }
76247
76248
76249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76250   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76251   unsigned int arg2 ;
76252   float arg3 ;
76253   Dali::Toolkit::DirectionBias arg4 ;
76254
76255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76256   arg2 = (unsigned int)jarg2;
76257   arg3 = (float)jarg3;
76258   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76259   {
76260     try {
76261       (arg1)->ScrollTo(arg2,arg3,arg4);
76262     } catch (std::out_of_range& e) {
76263       {
76264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76265       };
76266     } catch (std::exception& e) {
76267       {
76268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76269       };
76270     } catch (Dali::DaliException e) {
76271       {
76272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76273       };
76274     } catch (...) {
76275       {
76276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76277       };
76278     }
76279   }
76280
76281 }
76282
76283
76284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76286   Dali::Actor *arg2 = 0 ;
76287
76288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76289   arg2 = (Dali::Actor *)jarg2;
76290   if (!arg2) {
76291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76292     return ;
76293   }
76294   {
76295     try {
76296       (arg1)->ScrollTo(*arg2);
76297     } catch (std::out_of_range& e) {
76298       {
76299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76300       };
76301     } catch (std::exception& e) {
76302       {
76303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76304       };
76305     } catch (Dali::DaliException e) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76308       };
76309     } catch (...) {
76310       {
76311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76312       };
76313     }
76314   }
76315
76316 }
76317
76318
76319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76321   Dali::Actor *arg2 = 0 ;
76322   float arg3 ;
76323
76324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76325   arg2 = (Dali::Actor *)jarg2;
76326   if (!arg2) {
76327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76328     return ;
76329   }
76330   arg3 = (float)jarg3;
76331   {
76332     try {
76333       (arg1)->ScrollTo(*arg2,arg3);
76334     } catch (std::out_of_range& e) {
76335       {
76336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76337       };
76338     } catch (std::exception& e) {
76339       {
76340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76341       };
76342     } catch (Dali::DaliException e) {
76343       {
76344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76345       };
76346     } catch (...) {
76347       {
76348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76349       };
76350     }
76351   }
76352
76353 }
76354
76355
76356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76357   unsigned int jresult ;
76358   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76359   bool result;
76360
76361   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76362   {
76363     try {
76364       result = (bool)(arg1)->ScrollToSnapPoint();
76365     } catch (std::out_of_range& e) {
76366       {
76367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (std::exception& e) {
76370       {
76371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76372       };
76373     } catch (Dali::DaliException e) {
76374       {
76375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76376       };
76377     } catch (...) {
76378       {
76379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76380       };
76381     }
76382   }
76383
76384   jresult = result;
76385   return jresult;
76386 }
76387
76388
76389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76390   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76391   Dali::Constraint arg2 ;
76392   Dali::Constraint *argp2 ;
76393
76394   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76395   argp2 = (Dali::Constraint *)jarg2;
76396   if (!argp2) {
76397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76398     return ;
76399   }
76400   arg2 = *argp2;
76401   {
76402     try {
76403       (arg1)->ApplyConstraintToChildren(arg2);
76404     } catch (std::out_of_range& e) {
76405       {
76406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76407       };
76408     } catch (std::exception& e) {
76409       {
76410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76411       };
76412     } catch (Dali::DaliException e) {
76413       {
76414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76415       };
76416     } catch (...) {
76417       {
76418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76419       };
76420     }
76421   }
76422
76423 }
76424
76425
76426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76427   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76428
76429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76430   {
76431     try {
76432       (arg1)->RemoveConstraintsFromChildren();
76433     } catch (std::out_of_range& e) {
76434       {
76435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76436       };
76437     } catch (std::exception& e) {
76438       {
76439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76440       };
76441     } catch (Dali::DaliException e) {
76442       {
76443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76444       };
76445     } catch (...) {
76446       {
76447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76448       };
76449     }
76450   }
76451
76452 }
76453
76454
76455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76456   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76457   Dali::Toolkit::ScrollViewEffect arg2 ;
76458   Dali::Toolkit::ScrollViewEffect *argp2 ;
76459
76460   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76461   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76462   if (!argp2) {
76463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76464     return ;
76465   }
76466   arg2 = *argp2;
76467   {
76468     try {
76469       (arg1)->ApplyEffect(arg2);
76470     } catch (std::out_of_range& e) {
76471       {
76472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76473       };
76474     } catch (std::exception& e) {
76475       {
76476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76477       };
76478     } catch (Dali::DaliException e) {
76479       {
76480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76481       };
76482     } catch (...) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76485       };
76486     }
76487   }
76488
76489 }
76490
76491
76492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76494   Dali::Toolkit::ScrollViewEffect arg2 ;
76495   Dali::Toolkit::ScrollViewEffect *argp2 ;
76496
76497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76498   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76499   if (!argp2) {
76500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76501     return ;
76502   }
76503   arg2 = *argp2;
76504   {
76505     try {
76506       (arg1)->RemoveEffect(arg2);
76507     } catch (std::out_of_range& e) {
76508       {
76509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76510       };
76511     } catch (std::exception& e) {
76512       {
76513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76514       };
76515     } catch (Dali::DaliException e) {
76516       {
76517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76518       };
76519     } catch (...) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76522       };
76523     }
76524   }
76525
76526 }
76527
76528
76529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76531
76532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76533   {
76534     try {
76535       (arg1)->RemoveAllEffects();
76536     } catch (std::out_of_range& e) {
76537       {
76538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76539       };
76540     } catch (std::exception& e) {
76541       {
76542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76543       };
76544     } catch (Dali::DaliException e) {
76545       {
76546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76547       };
76548     } catch (...) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76551       };
76552     }
76553   }
76554
76555 }
76556
76557
76558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76560   Dali::Actor arg2 ;
76561   Dali::Actor *argp2 ;
76562
76563   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76564   argp2 = (Dali::Actor *)jarg2;
76565   if (!argp2) {
76566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76567     return ;
76568   }
76569   arg2 = *argp2;
76570   {
76571     try {
76572       (arg1)->BindActor(arg2);
76573     } catch (std::out_of_range& e) {
76574       {
76575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76576       };
76577     } catch (std::exception& e) {
76578       {
76579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76580       };
76581     } catch (Dali::DaliException e) {
76582       {
76583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76584       };
76585     } catch (...) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76588       };
76589     }
76590   }
76591
76592 }
76593
76594
76595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76596   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76597   Dali::Actor arg2 ;
76598   Dali::Actor *argp2 ;
76599
76600   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76601   argp2 = (Dali::Actor *)jarg2;
76602   if (!argp2) {
76603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76604     return ;
76605   }
76606   arg2 = *argp2;
76607   {
76608     try {
76609       (arg1)->UnbindActor(arg2);
76610     } catch (std::out_of_range& e) {
76611       {
76612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76613       };
76614     } catch (std::exception& e) {
76615       {
76616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76617       };
76618     } catch (Dali::DaliException e) {
76619       {
76620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76621       };
76622     } catch (...) {
76623       {
76624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76625       };
76626     }
76627   }
76628
76629 }
76630
76631
76632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76633   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76634   Dali::Radian arg2 ;
76635   Dali::Radian arg3 ;
76636   Dali::Radian *argp2 ;
76637   Dali::Radian *argp3 ;
76638
76639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76640   argp2 = (Dali::Radian *)jarg2;
76641   if (!argp2) {
76642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76643     return ;
76644   }
76645   arg2 = *argp2;
76646   argp3 = (Dali::Radian *)jarg3;
76647   if (!argp3) {
76648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76649     return ;
76650   }
76651   arg3 = *argp3;
76652   {
76653     try {
76654       (arg1)->SetScrollingDirection(arg2,arg3);
76655     } catch (std::out_of_range& e) {
76656       {
76657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76658       };
76659     } catch (std::exception& e) {
76660       {
76661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76662       };
76663     } catch (Dali::DaliException e) {
76664       {
76665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76666       };
76667     } catch (...) {
76668       {
76669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76670       };
76671     }
76672   }
76673
76674 }
76675
76676
76677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76679   Dali::Radian arg2 ;
76680   Dali::Radian *argp2 ;
76681
76682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76683   argp2 = (Dali::Radian *)jarg2;
76684   if (!argp2) {
76685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76686     return ;
76687   }
76688   arg2 = *argp2;
76689   {
76690     try {
76691       (arg1)->SetScrollingDirection(arg2);
76692     } catch (std::out_of_range& e) {
76693       {
76694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76695       };
76696     } catch (std::exception& e) {
76697       {
76698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76699       };
76700     } catch (Dali::DaliException e) {
76701       {
76702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76703       };
76704     } catch (...) {
76705       {
76706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76707       };
76708     }
76709   }
76710
76711 }
76712
76713
76714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76716   Dali::Radian arg2 ;
76717   Dali::Radian *argp2 ;
76718
76719   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76720   argp2 = (Dali::Radian *)jarg2;
76721   if (!argp2) {
76722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76723     return ;
76724   }
76725   arg2 = *argp2;
76726   {
76727     try {
76728       (arg1)->RemoveScrollingDirection(arg2);
76729     } catch (std::out_of_range& e) {
76730       {
76731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76732       };
76733     } catch (std::exception& e) {
76734       {
76735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76736       };
76737     } catch (Dali::DaliException e) {
76738       {
76739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76740       };
76741     } catch (...) {
76742       {
76743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76744       };
76745     }
76746   }
76747
76748 }
76749
76750
76751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76752   void * jresult ;
76753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76754   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76755
76756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76757   {
76758     try {
76759       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76760     } catch (std::out_of_range& e) {
76761       {
76762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76763       };
76764     } catch (std::exception& e) {
76765       {
76766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76767       };
76768     } catch (Dali::DaliException e) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76771       };
76772     } catch (...) {
76773       {
76774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76775       };
76776     }
76777   }
76778
76779   jresult = (void *)result;
76780   return jresult;
76781 }
76782
76783
76784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76785   int jresult ;
76786   int result;
76787
76788   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76789   jresult = (int)result;
76790   return jresult;
76791 }
76792
76793
76794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76795   int jresult ;
76796   int result;
76797
76798   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76799   jresult = (int)result;
76800   return jresult;
76801 }
76802
76803
76804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76805   int jresult ;
76806   int result;
76807
76808   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76809   jresult = (int)result;
76810   return jresult;
76811 }
76812
76813
76814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76815   int jresult ;
76816   int result;
76817
76818   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76819   jresult = (int)result;
76820   return jresult;
76821 }
76822
76823
76824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76825   int jresult ;
76826   int result;
76827
76828   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76829   jresult = (int)result;
76830   return jresult;
76831 }
76832
76833
76834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76835   void * jresult ;
76836   Dali::Toolkit::TableView::Property *result = 0 ;
76837
76838   {
76839     try {
76840       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76841     } catch (std::out_of_range& e) {
76842       {
76843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76844       };
76845     } catch (std::exception& e) {
76846       {
76847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76848       };
76849     } catch (Dali::DaliException e) {
76850       {
76851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76852       };
76853     } catch (...) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76856       };
76857     }
76858   }
76859
76860   jresult = (void *)result;
76861   return jresult;
76862 }
76863
76864
76865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76866   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76867
76868   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76869   {
76870     try {
76871       delete arg1;
76872     } catch (std::out_of_range& e) {
76873       {
76874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76875       };
76876     } catch (std::exception& e) {
76877       {
76878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76879       };
76880     } catch (Dali::DaliException e) {
76881       {
76882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76883       };
76884     } catch (...) {
76885       {
76886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76887       };
76888     }
76889   }
76890
76891 }
76892
76893
76894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76895   int jresult ;
76896   int result;
76897
76898   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76899   jresult = (int)result;
76900   return jresult;
76901 }
76902
76903
76904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76905   int jresult ;
76906   int result;
76907
76908   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76909   jresult = (int)result;
76910   return jresult;
76911 }
76912
76913
76914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76915   int jresult ;
76916   int result;
76917
76918   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76919   jresult = (int)result;
76920   return jresult;
76921 }
76922
76923
76924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76925   int jresult ;
76926   int result;
76927
76928   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76929   jresult = (int)result;
76930   return jresult;
76931 }
76932
76933
76934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76935   int jresult ;
76936   int result;
76937
76938   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76939   jresult = (int)result;
76940   return jresult;
76941 }
76942
76943
76944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76945   void * jresult ;
76946   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76947
76948   {
76949     try {
76950       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76951     } catch (std::out_of_range& e) {
76952       {
76953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (std::exception& e) {
76956       {
76957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76958       };
76959     } catch (Dali::DaliException e) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76962       };
76963     } catch (...) {
76964       {
76965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76966       };
76967     }
76968   }
76969
76970   jresult = (void *)result;
76971   return jresult;
76972 }
76973
76974
76975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76976   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76977
76978   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76979   {
76980     try {
76981       delete arg1;
76982     } catch (std::out_of_range& e) {
76983       {
76984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76985       };
76986     } catch (std::exception& e) {
76987       {
76988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76989       };
76990     } catch (Dali::DaliException e) {
76991       {
76992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76993       };
76994     } catch (...) {
76995       {
76996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76997       };
76998     }
76999   }
77000
77001 }
77002
77003
77004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77005   void * jresult ;
77006   unsigned int arg1 ;
77007   unsigned int arg2 ;
77008   unsigned int arg3 ;
77009   unsigned int arg4 ;
77010   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77011
77012   arg1 = (unsigned int)jarg1;
77013   arg2 = (unsigned int)jarg2;
77014   arg3 = (unsigned int)jarg3;
77015   arg4 = (unsigned int)jarg4;
77016   {
77017     try {
77018       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77019     } catch (std::out_of_range& e) {
77020       {
77021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77022       };
77023     } catch (std::exception& e) {
77024       {
77025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77026       };
77027     } catch (Dali::DaliException e) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77030       };
77031     } catch (...) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77034       };
77035     }
77036   }
77037
77038   jresult = (void *)result;
77039   return jresult;
77040 }
77041
77042
77043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77044   void * jresult ;
77045   unsigned int arg1 ;
77046   unsigned int arg2 ;
77047   unsigned int arg3 ;
77048   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77049
77050   arg1 = (unsigned int)jarg1;
77051   arg2 = (unsigned int)jarg2;
77052   arg3 = (unsigned int)jarg3;
77053   {
77054     try {
77055       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77056     } catch (std::out_of_range& e) {
77057       {
77058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77059       };
77060     } catch (std::exception& e) {
77061       {
77062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77063       };
77064     } catch (Dali::DaliException e) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77067       };
77068     } catch (...) {
77069       {
77070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77071       };
77072     }
77073   }
77074
77075   jresult = (void *)result;
77076   return jresult;
77077 }
77078
77079
77080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77081   void * jresult ;
77082   unsigned int arg1 ;
77083   unsigned int arg2 ;
77084   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77085
77086   arg1 = (unsigned int)jarg1;
77087   arg2 = (unsigned int)jarg2;
77088   {
77089     try {
77090       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77091     } catch (std::out_of_range& e) {
77092       {
77093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77094       };
77095     } catch (std::exception& e) {
77096       {
77097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77098       };
77099     } catch (Dali::DaliException e) {
77100       {
77101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77102       };
77103     } catch (...) {
77104       {
77105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77106       };
77107     }
77108   }
77109
77110   jresult = (void *)result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77116   void * jresult ;
77117   unsigned int arg1 ;
77118   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77119
77120   arg1 = (unsigned int)jarg1;
77121   {
77122     try {
77123       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77124     } catch (std::out_of_range& e) {
77125       {
77126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77127       };
77128     } catch (std::exception& e) {
77129       {
77130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77131       };
77132     } catch (Dali::DaliException e) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77135       };
77136     } catch (...) {
77137       {
77138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77139       };
77140     }
77141   }
77142
77143   jresult = (void *)result;
77144   return jresult;
77145 }
77146
77147
77148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77149   void * jresult ;
77150   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77151
77152   {
77153     try {
77154       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77162       };
77163     } catch (Dali::DaliException e) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77166       };
77167     } catch (...) {
77168       {
77169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77170       };
77171     }
77172   }
77173
77174   jresult = (void *)result;
77175   return jresult;
77176 }
77177
77178
77179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77180   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77181   unsigned int arg2 ;
77182
77183   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77184   arg2 = (unsigned int)jarg2;
77185   if (arg1) (arg1)->rowIndex = arg2;
77186 }
77187
77188
77189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77190   unsigned int jresult ;
77191   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77192   unsigned int result;
77193
77194   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77195   result = (unsigned int) ((arg1)->rowIndex);
77196   jresult = result;
77197   return jresult;
77198 }
77199
77200
77201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77202   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77203   unsigned int arg2 ;
77204
77205   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77206   arg2 = (unsigned int)jarg2;
77207   if (arg1) (arg1)->columnIndex = arg2;
77208 }
77209
77210
77211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77212   unsigned int jresult ;
77213   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77214   unsigned int result;
77215
77216   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77217   result = (unsigned int) ((arg1)->columnIndex);
77218   jresult = result;
77219   return jresult;
77220 }
77221
77222
77223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77224   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77225   unsigned int arg2 ;
77226
77227   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77228   arg2 = (unsigned int)jarg2;
77229   if (arg1) (arg1)->rowSpan = arg2;
77230 }
77231
77232
77233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77234   unsigned int jresult ;
77235   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77236   unsigned int result;
77237
77238   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77239   result = (unsigned int) ((arg1)->rowSpan);
77240   jresult = result;
77241   return jresult;
77242 }
77243
77244
77245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77246   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77247   unsigned int arg2 ;
77248
77249   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77250   arg2 = (unsigned int)jarg2;
77251   if (arg1) (arg1)->columnSpan = arg2;
77252 }
77253
77254
77255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77256   unsigned int jresult ;
77257   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77258   unsigned int result;
77259
77260   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77261   result = (unsigned int) ((arg1)->columnSpan);
77262   jresult = result;
77263   return jresult;
77264 }
77265
77266
77267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77268   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77269
77270   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77271   {
77272     try {
77273       delete arg1;
77274     } catch (std::out_of_range& e) {
77275       {
77276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77277       };
77278     } catch (std::exception& e) {
77279       {
77280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77281       };
77282     } catch (Dali::DaliException e) {
77283       {
77284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77285       };
77286     } catch (...) {
77287       {
77288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77289       };
77290     }
77291   }
77292
77293 }
77294
77295
77296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77297   void * jresult ;
77298   Dali::Toolkit::TableView *result = 0 ;
77299
77300   {
77301     try {
77302       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
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__SWIG_1(void * jarg1) {
77328   void * jresult ;
77329   Dali::Toolkit::TableView *arg1 = 0 ;
77330   Dali::Toolkit::TableView *result = 0 ;
77331
77332   arg1 = (Dali::Toolkit::TableView *)jarg1;
77333   if (!arg1) {
77334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77335     return 0;
77336   }
77337   {
77338     try {
77339       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77340     } catch (std::out_of_range& e) {
77341       {
77342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77343       };
77344     } catch (std::exception& e) {
77345       {
77346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77347       };
77348     } catch (Dali::DaliException e) {
77349       {
77350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77351       };
77352     } catch (...) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77355       };
77356     }
77357   }
77358
77359   jresult = (void *)result;
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77365   void * jresult ;
77366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77367   Dali::Toolkit::TableView *arg2 = 0 ;
77368   Dali::Toolkit::TableView *result = 0 ;
77369
77370   arg1 = (Dali::Toolkit::TableView *)jarg1;
77371   arg2 = (Dali::Toolkit::TableView *)jarg2;
77372   if (!arg2) {
77373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77374     return 0;
77375   }
77376   {
77377     try {
77378       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77379     } catch (std::out_of_range& e) {
77380       {
77381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77382       };
77383     } catch (std::exception& e) {
77384       {
77385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77386       };
77387     } catch (Dali::DaliException e) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77390       };
77391     } catch (...) {
77392       {
77393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77394       };
77395     }
77396   }
77397
77398   jresult = (void *)result;
77399   return jresult;
77400 }
77401
77402
77403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77404   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77405
77406   arg1 = (Dali::Toolkit::TableView *)jarg1;
77407   {
77408     try {
77409       delete arg1;
77410     } catch (std::out_of_range& e) {
77411       {
77412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77413       };
77414     } catch (std::exception& e) {
77415       {
77416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77417       };
77418     } catch (Dali::DaliException e) {
77419       {
77420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77421       };
77422     } catch (...) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77425       };
77426     }
77427   }
77428
77429 }
77430
77431
77432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77433   void * jresult ;
77434   unsigned int arg1 ;
77435   unsigned int arg2 ;
77436   Dali::Toolkit::TableView result;
77437
77438   arg1 = (unsigned int)jarg1;
77439   arg2 = (unsigned int)jarg2;
77440   {
77441     try {
77442       result = Dali::Toolkit::TableView::New(arg1,arg2);
77443     } catch (std::out_of_range& e) {
77444       {
77445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77446       };
77447     } catch (std::exception& e) {
77448       {
77449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77450       };
77451     } catch (Dali::DaliException e) {
77452       {
77453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77458       };
77459     }
77460   }
77461
77462   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77463   return jresult;
77464 }
77465
77466
77467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77468   void * jresult ;
77469   Dali::BaseHandle arg1 ;
77470   Dali::BaseHandle *argp1 ;
77471   Dali::Toolkit::TableView result;
77472
77473   argp1 = (Dali::BaseHandle *)jarg1;
77474   if (!argp1) {
77475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77476     return 0;
77477   }
77478   arg1 = *argp1;
77479   {
77480     try {
77481       result = Dali::Toolkit::TableView::DownCast(arg1);
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (Dali::DaliException e) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77493       };
77494     } catch (...) {
77495       {
77496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77497       };
77498     }
77499   }
77500
77501   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77502   return jresult;
77503 }
77504
77505
77506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77507   unsigned int jresult ;
77508   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77509   Dali::Actor arg2 ;
77510   Dali::Toolkit::TableView::CellPosition arg3 ;
77511   Dali::Actor *argp2 ;
77512   Dali::Toolkit::TableView::CellPosition *argp3 ;
77513   bool result;
77514
77515   arg1 = (Dali::Toolkit::TableView *)jarg1;
77516   argp2 = (Dali::Actor *)jarg2;
77517   if (!argp2) {
77518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77519     return 0;
77520   }
77521   arg2 = *argp2;
77522   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77523   if (!argp3) {
77524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77525     return 0;
77526   }
77527   arg3 = *argp3;
77528   {
77529     try {
77530       result = (bool)(arg1)->AddChild(arg2,arg3);
77531     } catch (std::out_of_range& e) {
77532       {
77533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77534       };
77535     } catch (std::exception& e) {
77536       {
77537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77538       };
77539     } catch (Dali::DaliException e) {
77540       {
77541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77542       };
77543     } catch (...) {
77544       {
77545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77546       };
77547     }
77548   }
77549
77550   jresult = result;
77551   return jresult;
77552 }
77553
77554
77555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77556   void * jresult ;
77557   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77558   Dali::Toolkit::TableView::CellPosition arg2 ;
77559   Dali::Toolkit::TableView::CellPosition *argp2 ;
77560   Dali::Actor result;
77561
77562   arg1 = (Dali::Toolkit::TableView *)jarg1;
77563   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77564   if (!argp2) {
77565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77566     return 0;
77567   }
77568   arg2 = *argp2;
77569   {
77570     try {
77571       result = (arg1)->GetChildAt(arg2);
77572     } catch (std::out_of_range& e) {
77573       {
77574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77575       };
77576     } catch (std::exception& e) {
77577       {
77578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77579       };
77580     } catch (Dali::DaliException e) {
77581       {
77582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77583       };
77584     } catch (...) {
77585       {
77586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77587       };
77588     }
77589   }
77590
77591   jresult = new Dali::Actor((const Dali::Actor &)result);
77592   return jresult;
77593 }
77594
77595
77596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77597   void * jresult ;
77598   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77599   Dali::Toolkit::TableView::CellPosition arg2 ;
77600   Dali::Toolkit::TableView::CellPosition *argp2 ;
77601   Dali::Actor result;
77602
77603   arg1 = (Dali::Toolkit::TableView *)jarg1;
77604   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77605   if (!argp2) {
77606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77607     return 0;
77608   }
77609   arg2 = *argp2;
77610   {
77611     try {
77612       result = (arg1)->RemoveChildAt(arg2);
77613     } catch (std::out_of_range& e) {
77614       {
77615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77616       };
77617     } catch (std::exception& e) {
77618       {
77619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77620       };
77621     } catch (Dali::DaliException e) {
77622       {
77623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77624       };
77625     } catch (...) {
77626       {
77627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77628       };
77629     }
77630   }
77631
77632   jresult = new Dali::Actor((const Dali::Actor &)result);
77633   return jresult;
77634 }
77635
77636
77637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77638   unsigned int jresult ;
77639   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77640   Dali::Actor arg2 ;
77641   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77642   Dali::Actor *argp2 ;
77643   bool result;
77644
77645   arg1 = (Dali::Toolkit::TableView *)jarg1;
77646   argp2 = (Dali::Actor *)jarg2;
77647   if (!argp2) {
77648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77649     return 0;
77650   }
77651   arg2 = *argp2;
77652   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77653   if (!arg3) {
77654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77655     return 0;
77656   }
77657   {
77658     try {
77659       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77660     } catch (std::out_of_range& e) {
77661       {
77662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77663       };
77664     } catch (std::exception& e) {
77665       {
77666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77667       };
77668     } catch (Dali::DaliException e) {
77669       {
77670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77671       };
77672     } catch (...) {
77673       {
77674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77675       };
77676     }
77677   }
77678
77679   jresult = result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77685   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77686   unsigned int arg2 ;
77687
77688   arg1 = (Dali::Toolkit::TableView *)jarg1;
77689   arg2 = (unsigned int)jarg2;
77690   {
77691     try {
77692       (arg1)->InsertRow(arg2);
77693     } catch (std::out_of_range& e) {
77694       {
77695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77696       };
77697     } catch (std::exception& e) {
77698       {
77699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77700       };
77701     } catch (Dali::DaliException e) {
77702       {
77703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77704       };
77705     } catch (...) {
77706       {
77707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77708       };
77709     }
77710   }
77711
77712 }
77713
77714
77715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77716   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77717   unsigned int arg2 ;
77718
77719   arg1 = (Dali::Toolkit::TableView *)jarg1;
77720   arg2 = (unsigned int)jarg2;
77721   {
77722     try {
77723       (arg1)->DeleteRow(arg2);
77724     } catch (std::out_of_range& e) {
77725       {
77726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77727       };
77728     } catch (std::exception& e) {
77729       {
77730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77731       };
77732     } catch (Dali::DaliException e) {
77733       {
77734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77735       };
77736     } catch (...) {
77737       {
77738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77739       };
77740     }
77741   }
77742
77743 }
77744
77745
77746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77747   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77748   unsigned int arg2 ;
77749   std::vector< Dali::Actor > *arg3 = 0 ;
77750
77751   arg1 = (Dali::Toolkit::TableView *)jarg1;
77752   arg2 = (unsigned int)jarg2;
77753   arg3 = (std::vector< Dali::Actor > *)jarg3;
77754   if (!arg3) {
77755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77756     return ;
77757   }
77758   {
77759     try {
77760       (arg1)->DeleteRow(arg2,*arg3);
77761     } catch (std::out_of_range& e) {
77762       {
77763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77764       };
77765     } catch (std::exception& e) {
77766       {
77767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77768       };
77769     } catch (Dali::DaliException e) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77772       };
77773     } catch (...) {
77774       {
77775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77776       };
77777     }
77778   }
77779
77780 }
77781
77782
77783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77784   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77785   unsigned int arg2 ;
77786
77787   arg1 = (Dali::Toolkit::TableView *)jarg1;
77788   arg2 = (unsigned int)jarg2;
77789   {
77790     try {
77791       (arg1)->InsertColumn(arg2);
77792     } catch (std::out_of_range& e) {
77793       {
77794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77795       };
77796     } catch (std::exception& e) {
77797       {
77798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77799       };
77800     } catch (Dali::DaliException e) {
77801       {
77802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77803       };
77804     } catch (...) {
77805       {
77806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77807       };
77808     }
77809   }
77810
77811 }
77812
77813
77814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77815   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77816   unsigned int arg2 ;
77817
77818   arg1 = (Dali::Toolkit::TableView *)jarg1;
77819   arg2 = (unsigned int)jarg2;
77820   {
77821     try {
77822       (arg1)->DeleteColumn(arg2);
77823     } catch (std::out_of_range& e) {
77824       {
77825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77826       };
77827     } catch (std::exception& e) {
77828       {
77829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77830       };
77831     } catch (Dali::DaliException e) {
77832       {
77833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77834       };
77835     } catch (...) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77838       };
77839     }
77840   }
77841
77842 }
77843
77844
77845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77846   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77847   unsigned int arg2 ;
77848   std::vector< Dali::Actor > *arg3 = 0 ;
77849
77850   arg1 = (Dali::Toolkit::TableView *)jarg1;
77851   arg2 = (unsigned int)jarg2;
77852   arg3 = (std::vector< Dali::Actor > *)jarg3;
77853   if (!arg3) {
77854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77855     return ;
77856   }
77857   {
77858     try {
77859       (arg1)->DeleteColumn(arg2,*arg3);
77860     } catch (std::out_of_range& e) {
77861       {
77862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77863       };
77864     } catch (std::exception& e) {
77865       {
77866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77867       };
77868     } catch (Dali::DaliException e) {
77869       {
77870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77871       };
77872     } catch (...) {
77873       {
77874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77875       };
77876     }
77877   }
77878
77879 }
77880
77881
77882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77883   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77884   unsigned int arg2 ;
77885   unsigned int arg3 ;
77886
77887   arg1 = (Dali::Toolkit::TableView *)jarg1;
77888   arg2 = (unsigned int)jarg2;
77889   arg3 = (unsigned int)jarg3;
77890   {
77891     try {
77892       (arg1)->Resize(arg2,arg3);
77893     } catch (std::out_of_range& e) {
77894       {
77895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77896       };
77897     } catch (std::exception& e) {
77898       {
77899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77900       };
77901     } catch (Dali::DaliException e) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77904       };
77905     } catch (...) {
77906       {
77907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77908       };
77909     }
77910   }
77911
77912 }
77913
77914
77915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77916   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77917   unsigned int arg2 ;
77918   unsigned int arg3 ;
77919   std::vector< Dali::Actor > *arg4 = 0 ;
77920
77921   arg1 = (Dali::Toolkit::TableView *)jarg1;
77922   arg2 = (unsigned int)jarg2;
77923   arg3 = (unsigned int)jarg3;
77924   arg4 = (std::vector< Dali::Actor > *)jarg4;
77925   if (!arg4) {
77926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77927     return ;
77928   }
77929   {
77930     try {
77931       (arg1)->Resize(arg2,arg3,*arg4);
77932     } catch (std::out_of_range& e) {
77933       {
77934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77935       };
77936     } catch (std::exception& e) {
77937       {
77938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77939       };
77940     } catch (Dali::DaliException e) {
77941       {
77942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77943       };
77944     } catch (...) {
77945       {
77946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77947       };
77948     }
77949   }
77950
77951 }
77952
77953
77954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77955   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77956   Dali::Size arg2 ;
77957   Dali::Size *argp2 ;
77958
77959   arg1 = (Dali::Toolkit::TableView *)jarg1;
77960   argp2 = (Dali::Size *)jarg2;
77961   if (!argp2) {
77962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77963     return ;
77964   }
77965   arg2 = *argp2;
77966   {
77967     try {
77968       (arg1)->SetCellPadding(arg2);
77969     } catch (std::out_of_range& e) {
77970       {
77971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77972       };
77973     } catch (std::exception& e) {
77974       {
77975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77976       };
77977     } catch (Dali::DaliException e) {
77978       {
77979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77980       };
77981     } catch (...) {
77982       {
77983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77984       };
77985     }
77986   }
77987
77988 }
77989
77990
77991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77992   void * jresult ;
77993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77994   Dali::Size result;
77995
77996   arg1 = (Dali::Toolkit::TableView *)jarg1;
77997   {
77998     try {
77999       result = (arg1)->GetCellPadding();
78000     } catch (std::out_of_range& e) {
78001       {
78002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78003       };
78004     } catch (std::exception& e) {
78005       {
78006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78007       };
78008     } catch (Dali::DaliException e) {
78009       {
78010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78011       };
78012     } catch (...) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78015       };
78016     }
78017   }
78018
78019   jresult = new Dali::Size((const Dali::Size &)result);
78020   return jresult;
78021 }
78022
78023
78024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78025   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78026   unsigned int arg2 ;
78027
78028   arg1 = (Dali::Toolkit::TableView *)jarg1;
78029   arg2 = (unsigned int)jarg2;
78030   {
78031     try {
78032       (arg1)->SetFitHeight(arg2);
78033     } catch (std::out_of_range& e) {
78034       {
78035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78036       };
78037     } catch (std::exception& e) {
78038       {
78039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78040       };
78041     } catch (Dali::DaliException e) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78048       };
78049     }
78050   }
78051
78052 }
78053
78054
78055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78056   unsigned int jresult ;
78057   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78058   unsigned int arg2 ;
78059   bool result;
78060
78061   arg1 = (Dali::Toolkit::TableView *)jarg1;
78062   arg2 = (unsigned int)jarg2;
78063   {
78064     try {
78065       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78066     } catch (std::out_of_range& e) {
78067       {
78068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78069       };
78070     } catch (std::exception& e) {
78071       {
78072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78073       };
78074     } catch (Dali::DaliException e) {
78075       {
78076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78077       };
78078     } catch (...) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78081       };
78082     }
78083   }
78084
78085   jresult = result;
78086   return jresult;
78087 }
78088
78089
78090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78092   unsigned int arg2 ;
78093
78094   arg1 = (Dali::Toolkit::TableView *)jarg1;
78095   arg2 = (unsigned int)jarg2;
78096   {
78097     try {
78098       (arg1)->SetFitWidth(arg2);
78099     } catch (std::out_of_range& e) {
78100       {
78101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78102       };
78103     } catch (std::exception& e) {
78104       {
78105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78106       };
78107     } catch (Dali::DaliException e) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78110       };
78111     } catch (...) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78114       };
78115     }
78116   }
78117
78118 }
78119
78120
78121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78122   unsigned int jresult ;
78123   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78124   unsigned int arg2 ;
78125   bool result;
78126
78127   arg1 = (Dali::Toolkit::TableView *)jarg1;
78128   arg2 = (unsigned int)jarg2;
78129   {
78130     try {
78131       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78132     } catch (std::out_of_range& e) {
78133       {
78134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78135       };
78136     } catch (std::exception& e) {
78137       {
78138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78139       };
78140     } catch (Dali::DaliException e) {
78141       {
78142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78143       };
78144     } catch (...) {
78145       {
78146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78147       };
78148     }
78149   }
78150
78151   jresult = result;
78152   return jresult;
78153 }
78154
78155
78156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78157   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78158   unsigned int arg2 ;
78159   float arg3 ;
78160
78161   arg1 = (Dali::Toolkit::TableView *)jarg1;
78162   arg2 = (unsigned int)jarg2;
78163   arg3 = (float)jarg3;
78164   {
78165     try {
78166       (arg1)->SetFixedHeight(arg2,arg3);
78167     } catch (std::out_of_range& e) {
78168       {
78169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78170       };
78171     } catch (std::exception& e) {
78172       {
78173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78174       };
78175     } catch (Dali::DaliException e) {
78176       {
78177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78178       };
78179     } catch (...) {
78180       {
78181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78182       };
78183     }
78184   }
78185
78186 }
78187
78188
78189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78190   float jresult ;
78191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78192   unsigned int arg2 ;
78193   float result;
78194
78195   arg1 = (Dali::Toolkit::TableView *)jarg1;
78196   arg2 = (unsigned int)jarg2;
78197   {
78198     try {
78199       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78200     } catch (std::out_of_range& e) {
78201       {
78202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78203       };
78204     } catch (std::exception& e) {
78205       {
78206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78207       };
78208     } catch (Dali::DaliException e) {
78209       {
78210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78211       };
78212     } catch (...) {
78213       {
78214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78215       };
78216     }
78217   }
78218
78219   jresult = result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78226   unsigned int arg2 ;
78227   float arg3 ;
78228
78229   arg1 = (Dali::Toolkit::TableView *)jarg1;
78230   arg2 = (unsigned int)jarg2;
78231   arg3 = (float)jarg3;
78232   {
78233     try {
78234       (arg1)->SetRelativeHeight(arg2,arg3);
78235     } catch (std::out_of_range& e) {
78236       {
78237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78238       };
78239     } catch (std::exception& e) {
78240       {
78241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78242       };
78243     } catch (Dali::DaliException e) {
78244       {
78245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78246       };
78247     } catch (...) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78250       };
78251     }
78252   }
78253
78254 }
78255
78256
78257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78258   float jresult ;
78259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78260   unsigned int arg2 ;
78261   float result;
78262
78263   arg1 = (Dali::Toolkit::TableView *)jarg1;
78264   arg2 = (unsigned int)jarg2;
78265   {
78266     try {
78267       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78268     } catch (std::out_of_range& e) {
78269       {
78270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78271       };
78272     } catch (std::exception& e) {
78273       {
78274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78275       };
78276     } catch (Dali::DaliException e) {
78277       {
78278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78279       };
78280     } catch (...) {
78281       {
78282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78283       };
78284     }
78285   }
78286
78287   jresult = result;
78288   return jresult;
78289 }
78290
78291
78292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78293   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78294   unsigned int arg2 ;
78295   float arg3 ;
78296
78297   arg1 = (Dali::Toolkit::TableView *)jarg1;
78298   arg2 = (unsigned int)jarg2;
78299   arg3 = (float)jarg3;
78300   {
78301     try {
78302       (arg1)->SetFixedWidth(arg2,arg3);
78303     } catch (std::out_of_range& e) {
78304       {
78305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78306       };
78307     } catch (std::exception& e) {
78308       {
78309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78310       };
78311     } catch (Dali::DaliException e) {
78312       {
78313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78314       };
78315     } catch (...) {
78316       {
78317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78318       };
78319     }
78320   }
78321
78322 }
78323
78324
78325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78326   float jresult ;
78327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78328   unsigned int arg2 ;
78329   float result;
78330
78331   arg1 = (Dali::Toolkit::TableView *)jarg1;
78332   arg2 = (unsigned int)jarg2;
78333   {
78334     try {
78335       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78336     } catch (std::out_of_range& e) {
78337       {
78338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78339       };
78340     } catch (std::exception& e) {
78341       {
78342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78343       };
78344     } catch (Dali::DaliException e) {
78345       {
78346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78347       };
78348     } catch (...) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78351       };
78352     }
78353   }
78354
78355   jresult = result;
78356   return jresult;
78357 }
78358
78359
78360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78362   unsigned int arg2 ;
78363   float arg3 ;
78364
78365   arg1 = (Dali::Toolkit::TableView *)jarg1;
78366   arg2 = (unsigned int)jarg2;
78367   arg3 = (float)jarg3;
78368   {
78369     try {
78370       (arg1)->SetRelativeWidth(arg2,arg3);
78371     } catch (std::out_of_range& e) {
78372       {
78373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78374       };
78375     } catch (std::exception& e) {
78376       {
78377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78378       };
78379     } catch (Dali::DaliException e) {
78380       {
78381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78382       };
78383     } catch (...) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78386       };
78387     }
78388   }
78389
78390 }
78391
78392
78393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78394   float jresult ;
78395   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78396   unsigned int arg2 ;
78397   float result;
78398
78399   arg1 = (Dali::Toolkit::TableView *)jarg1;
78400   arg2 = (unsigned int)jarg2;
78401   {
78402     try {
78403       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78404     } catch (std::out_of_range& e) {
78405       {
78406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78407       };
78408     } catch (std::exception& e) {
78409       {
78410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78411       };
78412     } catch (Dali::DaliException e) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78415       };
78416     } catch (...) {
78417       {
78418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78419       };
78420     }
78421   }
78422
78423   jresult = result;
78424   return jresult;
78425 }
78426
78427
78428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78429   unsigned int jresult ;
78430   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78431   unsigned int result;
78432
78433   arg1 = (Dali::Toolkit::TableView *)jarg1;
78434   {
78435     try {
78436       result = (unsigned int)(arg1)->GetRows();
78437     } catch (std::out_of_range& e) {
78438       {
78439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78440       };
78441     } catch (std::exception& e) {
78442       {
78443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (Dali::DaliException e) {
78446       {
78447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455
78456   jresult = result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78462   unsigned int jresult ;
78463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78464   unsigned int result;
78465
78466   arg1 = (Dali::Toolkit::TableView *)jarg1;
78467   {
78468     try {
78469       result = (unsigned int)(arg1)->GetColumns();
78470     } catch (std::out_of_range& e) {
78471       {
78472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78473       };
78474     } catch (std::exception& e) {
78475       {
78476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78477       };
78478     } catch (Dali::DaliException e) {
78479       {
78480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78481       };
78482     } catch (...) {
78483       {
78484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78485       };
78486     }
78487   }
78488
78489   jresult = result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78495   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78496   Dali::Toolkit::TableView::CellPosition arg2 ;
78497   Dali::HorizontalAlignment::Type arg3 ;
78498   Dali::VerticalAlignment::Type arg4 ;
78499   Dali::Toolkit::TableView::CellPosition *argp2 ;
78500
78501   arg1 = (Dali::Toolkit::TableView *)jarg1;
78502   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78503   if (!argp2) {
78504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78505     return ;
78506   }
78507   arg2 = *argp2;
78508   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78509   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78510   {
78511     try {
78512       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78513     } catch (std::out_of_range& e) {
78514       {
78515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78516       };
78517     } catch (std::exception& e) {
78518       {
78519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78520       };
78521     } catch (Dali::DaliException e) {
78522       {
78523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78524       };
78525     } catch (...) {
78526       {
78527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78528       };
78529     }
78530   }
78531
78532 }
78533
78534
78535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78536   unsigned int jresult ;
78537   unsigned int result;
78538
78539   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78540   jresult = result;
78541   return jresult;
78542 }
78543
78544
78545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78546   int jresult ;
78547   int result;
78548
78549   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78550   jresult = (int)result;
78551   return jresult;
78552 }
78553
78554
78555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78556   int jresult ;
78557   int result;
78558
78559   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78560   jresult = (int)result;
78561   return jresult;
78562 }
78563
78564
78565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78566   int jresult ;
78567   int result;
78568
78569   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78570   jresult = (int)result;
78571   return jresult;
78572 }
78573
78574
78575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78576   int jresult ;
78577   int result;
78578
78579   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78580   jresult = (int)result;
78581   return jresult;
78582 }
78583
78584
78585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78586   int jresult ;
78587   int result;
78588
78589   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78590   jresult = (int)result;
78591   return jresult;
78592 }
78593
78594
78595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78596   int jresult ;
78597   int result;
78598
78599   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78600   jresult = (int)result;
78601   return jresult;
78602 }
78603
78604
78605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78606   int jresult ;
78607   int result;
78608
78609   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78610   jresult = (int)result;
78611   return jresult;
78612 }
78613
78614
78615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78616   int jresult ;
78617   int result;
78618
78619   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78620   jresult = (int)result;
78621   return jresult;
78622 }
78623
78624
78625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78626   int jresult ;
78627   int result;
78628
78629   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78630   jresult = (int)result;
78631   return jresult;
78632 }
78633
78634
78635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78636   int jresult ;
78637   int result;
78638
78639   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78640   jresult = (int)result;
78641   return jresult;
78642 }
78643
78644
78645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78646   int jresult ;
78647   int result;
78648
78649   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78650   jresult = (int)result;
78651   return jresult;
78652 }
78653
78654
78655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78656   int jresult ;
78657   int result;
78658
78659   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78660   jresult = (int)result;
78661   return jresult;
78662 }
78663
78664
78665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78666   int jresult ;
78667   int result;
78668
78669   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78670   jresult = (int)result;
78671   return jresult;
78672 }
78673
78674
78675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78676   int jresult ;
78677   int result;
78678
78679   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78680   jresult = (int)result;
78681   return jresult;
78682 }
78683
78684
78685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78686   int jresult ;
78687   int result;
78688
78689   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78690   jresult = (int)result;
78691   return jresult;
78692 }
78693
78694
78695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78696   int jresult ;
78697   int result;
78698
78699   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78700   jresult = (int)result;
78701   return jresult;
78702 }
78703
78704
78705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78706   int jresult ;
78707   int result;
78708
78709   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78710   jresult = (int)result;
78711   return jresult;
78712 }
78713
78714
78715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78716   int jresult ;
78717   int result;
78718
78719   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78720   jresult = (int)result;
78721   return jresult;
78722 }
78723
78724
78725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78726   void * jresult ;
78727   Dali::Toolkit::TextLabel::Property *result = 0 ;
78728
78729   {
78730     try {
78731       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78732     } catch (std::out_of_range& e) {
78733       {
78734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78735       };
78736     } catch (std::exception& e) {
78737       {
78738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78739       };
78740     } catch (Dali::DaliException e) {
78741       {
78742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78743       };
78744     } catch (...) {
78745       {
78746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78747       };
78748     }
78749   }
78750
78751   jresult = (void *)result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78757   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78758
78759   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78760   {
78761     try {
78762       delete arg1;
78763     } catch (std::out_of_range& e) {
78764       {
78765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78766       };
78767     } catch (std::exception& e) {
78768       {
78769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78770       };
78771     } catch (Dali::DaliException e) {
78772       {
78773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78774       };
78775     } catch (...) {
78776       {
78777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78778       };
78779     }
78780   }
78781
78782 }
78783
78784
78785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78786   void * jresult ;
78787   Dali::Toolkit::TextLabel result;
78788
78789   {
78790     try {
78791       result = Dali::Toolkit::TextLabel::New();
78792     } catch (std::out_of_range& e) {
78793       {
78794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78795       };
78796     } catch (std::exception& e) {
78797       {
78798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78799       };
78800     } catch (Dali::DaliException e) {
78801       {
78802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78803       };
78804     } catch (...) {
78805       {
78806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78807       };
78808     }
78809   }
78810
78811   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78812   return jresult;
78813 }
78814
78815
78816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78817   void * jresult ;
78818   std::string *arg1 = 0 ;
78819   Dali::Toolkit::TextLabel result;
78820
78821   if (!jarg1) {
78822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78823     return 0;
78824   }
78825   std::string arg1_str(jarg1);
78826   arg1 = &arg1_str;
78827   {
78828     try {
78829       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78830     } catch (std::out_of_range& e) {
78831       {
78832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78833       };
78834     } catch (std::exception& e) {
78835       {
78836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78837       };
78838     } catch (Dali::DaliException e) {
78839       {
78840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78841       };
78842     } catch (...) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78845       };
78846     }
78847   }
78848
78849   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78850
78851   //argout typemap for const std::string&
78852
78853   return jresult;
78854 }
78855
78856
78857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78858   void * jresult ;
78859   Dali::Toolkit::TextLabel *result = 0 ;
78860
78861   {
78862     try {
78863       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78864     } catch (std::out_of_range& e) {
78865       {
78866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78867       };
78868     } catch (std::exception& e) {
78869       {
78870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78871       };
78872     } catch (Dali::DaliException e) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78875       };
78876     } catch (...) {
78877       {
78878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78879       };
78880     }
78881   }
78882
78883   jresult = (void *)result;
78884   return jresult;
78885 }
78886
78887
78888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78889   void * jresult ;
78890   Dali::Toolkit::TextLabel *arg1 = 0 ;
78891   Dali::Toolkit::TextLabel *result = 0 ;
78892
78893   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78894   if (!arg1) {
78895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78896     return 0;
78897   }
78898   {
78899     try {
78900       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78901     } catch (std::out_of_range& e) {
78902       {
78903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78904       };
78905     } catch (std::exception& e) {
78906       {
78907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78908       };
78909     } catch (Dali::DaliException e) {
78910       {
78911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78912       };
78913     } catch (...) {
78914       {
78915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78916       };
78917     }
78918   }
78919
78920   jresult = (void *)result;
78921   return jresult;
78922 }
78923
78924
78925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78926   void * jresult ;
78927   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78928   Dali::Toolkit::TextLabel *arg2 = 0 ;
78929   Dali::Toolkit::TextLabel *result = 0 ;
78930
78931   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78932   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78933   if (!arg2) {
78934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78935     return 0;
78936   }
78937   {
78938     try {
78939       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78940     } catch (std::out_of_range& e) {
78941       {
78942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78943       };
78944     } catch (std::exception& e) {
78945       {
78946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78947       };
78948     } catch (Dali::DaliException e) {
78949       {
78950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78951       };
78952     } catch (...) {
78953       {
78954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78955       };
78956     }
78957   }
78958
78959   jresult = (void *)result;
78960   return jresult;
78961 }
78962
78963
78964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78965   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78966
78967   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78968   {
78969     try {
78970       delete arg1;
78971     } catch (std::out_of_range& e) {
78972       {
78973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78974       };
78975     } catch (std::exception& e) {
78976       {
78977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78978       };
78979     } catch (Dali::DaliException e) {
78980       {
78981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78982       };
78983     } catch (...) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78986       };
78987     }
78988   }
78989
78990 }
78991
78992
78993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78994   void * jresult ;
78995   Dali::BaseHandle arg1 ;
78996   Dali::BaseHandle *argp1 ;
78997   Dali::Toolkit::TextLabel result;
78998
78999   argp1 = (Dali::BaseHandle *)jarg1;
79000   if (!argp1) {
79001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79002     return 0;
79003   }
79004   arg1 = *argp1;
79005   {
79006     try {
79007       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79008     } catch (std::out_of_range& e) {
79009       {
79010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79011       };
79012     } catch (std::exception& e) {
79013       {
79014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79015       };
79016     } catch (Dali::DaliException e) {
79017       {
79018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79019       };
79020     } catch (...) {
79021       {
79022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79023       };
79024     }
79025   }
79026
79027   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79028   return jresult;
79029 }
79030
79031
79032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79033   void * jresult ;
79034   Dali::Toolkit::AccessibilityManager *result = 0 ;
79035
79036   {
79037     try {
79038       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79039     } catch (std::out_of_range& e) {
79040       {
79041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79042       };
79043     } catch (std::exception& e) {
79044       {
79045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79046       };
79047     } catch (Dali::DaliException e) {
79048       {
79049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79050       };
79051     } catch (...) {
79052       {
79053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79054       };
79055     }
79056   }
79057
79058   jresult = (void *)result;
79059   return jresult;
79060 }
79061
79062
79063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79065
79066   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79067   {
79068     try {
79069       delete arg1;
79070     } catch (std::out_of_range& e) {
79071       {
79072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79073       };
79074     } catch (std::exception& e) {
79075       {
79076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79077       };
79078     } catch (Dali::DaliException e) {
79079       {
79080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79081       };
79082     } catch (...) {
79083       {
79084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79085       };
79086     }
79087   }
79088
79089 }
79090
79091
79092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79093   void * jresult ;
79094   Dali::Toolkit::AccessibilityManager result;
79095
79096   {
79097     try {
79098       result = Dali::Toolkit::AccessibilityManager::Get();
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79106       };
79107     } catch (Dali::DaliException e) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79110       };
79111     } catch (...) {
79112       {
79113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79114       };
79115     }
79116   }
79117
79118   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79119   return jresult;
79120 }
79121
79122
79123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79124   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79125   Dali::Actor arg2 ;
79126   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79127   std::string *arg4 = 0 ;
79128   Dali::Actor *argp2 ;
79129
79130   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79131   argp2 = (Dali::Actor *)jarg2;
79132   if (!argp2) {
79133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79134     return ;
79135   }
79136   arg2 = *argp2;
79137   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79138   if (!jarg4) {
79139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79140     return ;
79141   }
79142   std::string arg4_str(jarg4);
79143   arg4 = &arg4_str;
79144   {
79145     try {
79146       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79147     } catch (std::out_of_range& e) {
79148       {
79149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79150       };
79151     } catch (std::exception& e) {
79152       {
79153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79154       };
79155     } catch (Dali::DaliException e) {
79156       {
79157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79158       };
79159     } catch (...) {
79160       {
79161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79162       };
79163     }
79164   }
79165
79166
79167   //argout typemap for const std::string&
79168
79169 }
79170
79171
79172 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79173   char * jresult ;
79174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79175   Dali::Actor arg2 ;
79176   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79177   Dali::Actor *argp2 ;
79178   std::string result;
79179
79180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79181   argp2 = (Dali::Actor *)jarg2;
79182   if (!argp2) {
79183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79184     return 0;
79185   }
79186   arg2 = *argp2;
79187   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79188   {
79189     try {
79190       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79191     } catch (std::out_of_range& e) {
79192       {
79193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79194       };
79195     } catch (std::exception& e) {
79196       {
79197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79198       };
79199     } catch (Dali::DaliException e) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79202       };
79203     } catch (...) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79206       };
79207     }
79208   }
79209
79210   jresult = SWIG_csharp_string_callback((&result)->c_str());
79211   return jresult;
79212 }
79213
79214
79215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79216   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79217   Dali::Actor arg2 ;
79218   unsigned int arg3 ;
79219   Dali::Actor *argp2 ;
79220
79221   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79222   argp2 = (Dali::Actor *)jarg2;
79223   if (!argp2) {
79224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79225     return ;
79226   }
79227   arg2 = *argp2;
79228   arg3 = (unsigned int)jarg3;
79229   {
79230     try {
79231       (arg1)->SetFocusOrder(arg2,arg3);
79232     } catch (std::out_of_range& e) {
79233       {
79234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79235       };
79236     } catch (std::exception& e) {
79237       {
79238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79239       };
79240     } catch (Dali::DaliException e) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79243       };
79244     } catch (...) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79247       };
79248     }
79249   }
79250
79251 }
79252
79253
79254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79255   unsigned int jresult ;
79256   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79257   Dali::Actor arg2 ;
79258   Dali::Actor *argp2 ;
79259   unsigned int result;
79260
79261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79262   argp2 = (Dali::Actor *)jarg2;
79263   if (!argp2) {
79264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79265     return 0;
79266   }
79267   arg2 = *argp2;
79268   {
79269     try {
79270       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (Dali::DaliException e) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289
79290   jresult = result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79296   unsigned int jresult ;
79297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79298   unsigned int result;
79299
79300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79301   {
79302     try {
79303       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79304     } catch (std::out_of_range& e) {
79305       {
79306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79307       };
79308     } catch (std::exception& e) {
79309       {
79310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79311       };
79312     } catch (Dali::DaliException e) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79315       };
79316     } catch (...) {
79317       {
79318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79319       };
79320     }
79321   }
79322
79323   jresult = result;
79324   return jresult;
79325 }
79326
79327
79328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79329   void * jresult ;
79330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79331   unsigned int arg2 ;
79332   Dali::Actor result;
79333
79334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79335   arg2 = (unsigned int)jarg2;
79336   {
79337     try {
79338       result = (arg1)->GetActorByFocusOrder(arg2);
79339     } catch (std::out_of_range& e) {
79340       {
79341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (std::exception& e) {
79344       {
79345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79346       };
79347     } catch (Dali::DaliException e) {
79348       {
79349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79350       };
79351     } catch (...) {
79352       {
79353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79354       };
79355     }
79356   }
79357
79358   jresult = new Dali::Actor((const Dali::Actor &)result);
79359   return jresult;
79360 }
79361
79362
79363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79364   unsigned int jresult ;
79365   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79366   Dali::Actor arg2 ;
79367   Dali::Actor *argp2 ;
79368   bool result;
79369
79370   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79371   argp2 = (Dali::Actor *)jarg2;
79372   if (!argp2) {
79373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79374     return 0;
79375   }
79376   arg2 = *argp2;
79377   {
79378     try {
79379       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79380     } catch (std::out_of_range& e) {
79381       {
79382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79383       };
79384     } catch (std::exception& e) {
79385       {
79386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79387       };
79388     } catch (Dali::DaliException e) {
79389       {
79390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79391       };
79392     } catch (...) {
79393       {
79394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79395       };
79396     }
79397   }
79398
79399   jresult = result;
79400   return jresult;
79401 }
79402
79403
79404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79405   void * jresult ;
79406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79407   Dali::Actor result;
79408
79409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79410   {
79411     try {
79412       result = (arg1)->GetCurrentFocusActor();
79413     } catch (std::out_of_range& e) {
79414       {
79415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79416       };
79417     } catch (std::exception& e) {
79418       {
79419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79420       };
79421     } catch (Dali::DaliException e) {
79422       {
79423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79424       };
79425     } catch (...) {
79426       {
79427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79428       };
79429     }
79430   }
79431
79432   jresult = new Dali::Actor((const Dali::Actor &)result);
79433   return jresult;
79434 }
79435
79436
79437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79438   void * jresult ;
79439   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79440   Dali::Actor result;
79441
79442   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79443   {
79444     try {
79445       result = (arg1)->GetCurrentFocusGroup();
79446     } catch (std::out_of_range& e) {
79447       {
79448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79449       };
79450     } catch (std::exception& e) {
79451       {
79452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79453       };
79454     } catch (Dali::DaliException e) {
79455       {
79456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79457       };
79458     } catch (...) {
79459       {
79460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79461       };
79462     }
79463   }
79464
79465   jresult = new Dali::Actor((const Dali::Actor &)result);
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79471   unsigned int jresult ;
79472   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79473   unsigned int result;
79474
79475   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79476   {
79477     try {
79478       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79479     } catch (std::out_of_range& e) {
79480       {
79481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79482       };
79483     } catch (std::exception& e) {
79484       {
79485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79486       };
79487     } catch (Dali::DaliException e) {
79488       {
79489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79490       };
79491     } catch (...) {
79492       {
79493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79494       };
79495     }
79496   }
79497
79498   jresult = result;
79499   return jresult;
79500 }
79501
79502
79503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79504   unsigned int jresult ;
79505   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79506   bool result;
79507
79508   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79509   {
79510     try {
79511       result = (bool)(arg1)->MoveFocusForward();
79512     } catch (std::out_of_range& e) {
79513       {
79514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79515       };
79516     } catch (std::exception& e) {
79517       {
79518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79519       };
79520     } catch (Dali::DaliException e) {
79521       {
79522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79523       };
79524     } catch (...) {
79525       {
79526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79527       };
79528     }
79529   }
79530
79531   jresult = result;
79532   return jresult;
79533 }
79534
79535
79536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79537   unsigned int jresult ;
79538   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79539   bool result;
79540
79541   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79542   {
79543     try {
79544       result = (bool)(arg1)->MoveFocusBackward();
79545     } catch (std::out_of_range& e) {
79546       {
79547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79548       };
79549     } catch (std::exception& e) {
79550       {
79551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79552       };
79553     } catch (Dali::DaliException e) {
79554       {
79555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79556       };
79557     } catch (...) {
79558       {
79559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79560       };
79561     }
79562   }
79563
79564   jresult = result;
79565   return jresult;
79566 }
79567
79568
79569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79571
79572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79573   {
79574     try {
79575       (arg1)->ClearFocus();
79576     } catch (std::out_of_range& e) {
79577       {
79578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79579       };
79580     } catch (std::exception& e) {
79581       {
79582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79583       };
79584     } catch (Dali::DaliException e) {
79585       {
79586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79587       };
79588     } catch (...) {
79589       {
79590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79591       };
79592     }
79593   }
79594
79595 }
79596
79597
79598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79599   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79600
79601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79602   {
79603     try {
79604       (arg1)->Reset();
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79612       };
79613     } catch (Dali::DaliException e) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79616       };
79617     } catch (...) {
79618       {
79619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79620       };
79621     }
79622   }
79623
79624 }
79625
79626
79627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79628   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79629   Dali::Actor arg2 ;
79630   bool arg3 ;
79631   Dali::Actor *argp2 ;
79632
79633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79634   argp2 = (Dali::Actor *)jarg2;
79635   if (!argp2) {
79636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79637     return ;
79638   }
79639   arg2 = *argp2;
79640   arg3 = jarg3 ? true : false;
79641   {
79642     try {
79643       (arg1)->SetFocusGroup(arg2,arg3);
79644     } catch (std::out_of_range& e) {
79645       {
79646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79647       };
79648     } catch (std::exception& e) {
79649       {
79650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79651       };
79652     } catch (Dali::DaliException e) {
79653       {
79654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79655       };
79656     } catch (...) {
79657       {
79658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79659       };
79660     }
79661   }
79662
79663 }
79664
79665
79666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79667   unsigned int jresult ;
79668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79669   Dali::Actor arg2 ;
79670   Dali::Actor *argp2 ;
79671   bool result;
79672
79673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79674   argp2 = (Dali::Actor *)jarg2;
79675   if (!argp2) {
79676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79677     return 0;
79678   }
79679   arg2 = *argp2;
79680   {
79681     try {
79682       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79683     } catch (std::out_of_range& e) {
79684       {
79685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79686       };
79687     } catch (std::exception& e) {
79688       {
79689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79690       };
79691     } catch (Dali::DaliException e) {
79692       {
79693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79694       };
79695     } catch (...) {
79696       {
79697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79698       };
79699     }
79700   }
79701
79702   jresult = result;
79703   return jresult;
79704 }
79705
79706
79707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79708   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79709   bool arg2 ;
79710
79711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79712   arg2 = jarg2 ? true : false;
79713   {
79714     try {
79715       (arg1)->SetGroupMode(arg2);
79716     } catch (std::out_of_range& e) {
79717       {
79718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79719       };
79720     } catch (std::exception& e) {
79721       {
79722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79723       };
79724     } catch (Dali::DaliException e) {
79725       {
79726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79727       };
79728     } catch (...) {
79729       {
79730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79731       };
79732     }
79733   }
79734
79735 }
79736
79737
79738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79739   unsigned int jresult ;
79740   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79741   bool result;
79742
79743   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79744   {
79745     try {
79746       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79747     } catch (std::out_of_range& e) {
79748       {
79749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79750       };
79751     } catch (std::exception& e) {
79752       {
79753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79754       };
79755     } catch (Dali::DaliException e) {
79756       {
79757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79758       };
79759     } catch (...) {
79760       {
79761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79762       };
79763     }
79764   }
79765
79766   jresult = result;
79767   return jresult;
79768 }
79769
79770
79771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79772   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79773   bool arg2 ;
79774
79775   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79776   arg2 = jarg2 ? true : false;
79777   {
79778     try {
79779       (arg1)->SetWrapMode(arg2);
79780     } catch (std::out_of_range& e) {
79781       {
79782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79783       };
79784     } catch (std::exception& e) {
79785       {
79786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79787       };
79788     } catch (Dali::DaliException e) {
79789       {
79790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79791       };
79792     } catch (...) {
79793       {
79794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79795       };
79796     }
79797   }
79798
79799 }
79800
79801
79802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79803   unsigned int jresult ;
79804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79805   bool result;
79806
79807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79808   {
79809     try {
79810       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79811     } catch (std::out_of_range& e) {
79812       {
79813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79814       };
79815     } catch (std::exception& e) {
79816       {
79817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79818       };
79819     } catch (Dali::DaliException e) {
79820       {
79821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79822       };
79823     } catch (...) {
79824       {
79825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79826       };
79827     }
79828   }
79829
79830   jresult = result;
79831   return jresult;
79832 }
79833
79834
79835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79837   Dali::Actor arg2 ;
79838   Dali::Actor *argp2 ;
79839
79840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79841   argp2 = (Dali::Actor *)jarg2;
79842   if (!argp2) {
79843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79844     return ;
79845   }
79846   arg2 = *argp2;
79847   {
79848     try {
79849       (arg1)->SetFocusIndicatorActor(arg2);
79850     } catch (std::out_of_range& e) {
79851       {
79852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79853       };
79854     } catch (std::exception& e) {
79855       {
79856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79857       };
79858     } catch (Dali::DaliException e) {
79859       {
79860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79861       };
79862     } catch (...) {
79863       {
79864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79865       };
79866     }
79867   }
79868
79869 }
79870
79871
79872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79873   void * jresult ;
79874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79875   Dali::Actor result;
79876
79877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79878   {
79879     try {
79880       result = (arg1)->GetFocusIndicatorActor();
79881     } catch (std::out_of_range& e) {
79882       {
79883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79884       };
79885     } catch (std::exception& e) {
79886       {
79887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79888       };
79889     } catch (Dali::DaliException e) {
79890       {
79891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79892       };
79893     } catch (...) {
79894       {
79895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79896       };
79897     }
79898   }
79899
79900   jresult = new Dali::Actor((const Dali::Actor &)result);
79901   return jresult;
79902 }
79903
79904
79905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79906   void * jresult ;
79907   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79908   Dali::Actor arg2 ;
79909   Dali::Actor *argp2 ;
79910   Dali::Actor result;
79911
79912   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79913   argp2 = (Dali::Actor *)jarg2;
79914   if (!argp2) {
79915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79916     return 0;
79917   }
79918   arg2 = *argp2;
79919   {
79920     try {
79921       result = (arg1)->GetFocusGroup(arg2);
79922     } catch (std::out_of_range& e) {
79923       {
79924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79925       };
79926     } catch (std::exception& e) {
79927       {
79928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79929       };
79930     } catch (Dali::DaliException e) {
79931       {
79932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79933       };
79934     } catch (...) {
79935       {
79936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79937       };
79938     }
79939   }
79940
79941   jresult = new Dali::Actor((const Dali::Actor &)result);
79942   return jresult;
79943 }
79944
79945
79946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79947   void * jresult ;
79948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79949   Dali::Vector2 result;
79950
79951   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79952   {
79953     try {
79954       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79955     } catch (std::out_of_range& e) {
79956       {
79957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79958       };
79959     } catch (std::exception& e) {
79960       {
79961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79962       };
79963     } catch (Dali::DaliException e) {
79964       {
79965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79966       };
79967     } catch (...) {
79968       {
79969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79970       };
79971     }
79972   }
79973
79974   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79975   return jresult;
79976 }
79977
79978
79979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79980   void * jresult ;
79981   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79982   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79983
79984   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79985   {
79986     try {
79987       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79988     } catch (std::out_of_range& e) {
79989       {
79990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79991       };
79992     } catch (std::exception& e) {
79993       {
79994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79995       };
79996     } catch (Dali::DaliException e) {
79997       {
79998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79999       };
80000     } catch (...) {
80001       {
80002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80003       };
80004     }
80005   }
80006
80007   jresult = (void *)result;
80008   return jresult;
80009 }
80010
80011
80012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80013   void * jresult ;
80014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80015   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80016
80017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80018   {
80019     try {
80020       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80021     } catch (std::out_of_range& e) {
80022       {
80023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80024       };
80025     } catch (std::exception& e) {
80026       {
80027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80028       };
80029     } catch (Dali::DaliException e) {
80030       {
80031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80032       };
80033     } catch (...) {
80034       {
80035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80036       };
80037     }
80038   }
80039
80040   jresult = (void *)result;
80041   return jresult;
80042 }
80043
80044
80045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80046   void * jresult ;
80047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80048   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80049
80050   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80051   {
80052     try {
80053       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80054     } catch (std::out_of_range& e) {
80055       {
80056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80057       };
80058     } catch (std::exception& e) {
80059       {
80060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80061       };
80062     } catch (Dali::DaliException e) {
80063       {
80064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80065       };
80066     } catch (...) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80069       };
80070     }
80071   }
80072
80073   jresult = (void *)result;
80074   return jresult;
80075 }
80076
80077
80078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80079   void * jresult ;
80080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80081   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80082
80083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80084   {
80085     try {
80086       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80087     } catch (std::out_of_range& e) {
80088       {
80089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80090       };
80091     } catch (std::exception& e) {
80092       {
80093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80094       };
80095     } catch (Dali::DaliException e) {
80096       {
80097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80098       };
80099     } catch (...) {
80100       {
80101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80102       };
80103     }
80104   }
80105
80106   jresult = (void *)result;
80107   return jresult;
80108 }
80109
80110
80111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80112   void * jresult ;
80113   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80114   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80115
80116   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80117   {
80118     try {
80119       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80120     } catch (std::out_of_range& e) {
80121       {
80122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80123       };
80124     } catch (std::exception& e) {
80125       {
80126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80127       };
80128     } catch (Dali::DaliException e) {
80129       {
80130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80131       };
80132     } catch (...) {
80133       {
80134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80135       };
80136     }
80137   }
80138
80139   jresult = (void *)result;
80140   return jresult;
80141 }
80142
80143
80144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80145   void * jresult ;
80146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80147   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80148
80149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80150   {
80151     try {
80152       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80153     } catch (std::out_of_range& e) {
80154       {
80155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80156       };
80157     } catch (std::exception& e) {
80158       {
80159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80160       };
80161     } catch (Dali::DaliException e) {
80162       {
80163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80164       };
80165     } catch (...) {
80166       {
80167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80168       };
80169     }
80170   }
80171
80172   jresult = (void *)result;
80173   return jresult;
80174 }
80175
80176
80177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80178   void * jresult ;
80179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80180   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80181
80182   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80183   {
80184     try {
80185       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80186     } catch (std::out_of_range& e) {
80187       {
80188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80189       };
80190     } catch (std::exception& e) {
80191       {
80192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80193       };
80194     } catch (Dali::DaliException e) {
80195       {
80196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80197       };
80198     } catch (...) {
80199       {
80200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80201       };
80202     }
80203   }
80204
80205   jresult = (void *)result;
80206   return jresult;
80207 }
80208
80209
80210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80211   void * jresult ;
80212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80213   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80214
80215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80216   {
80217     try {
80218       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80219     } catch (std::out_of_range& e) {
80220       {
80221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80222       };
80223     } catch (std::exception& e) {
80224       {
80225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80226       };
80227     } catch (Dali::DaliException e) {
80228       {
80229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80230       };
80231     } catch (...) {
80232       {
80233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80234       };
80235     }
80236   }
80237
80238   jresult = (void *)result;
80239   return jresult;
80240 }
80241
80242
80243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80244   void * jresult ;
80245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80246   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80247
80248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80249   {
80250     try {
80251       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80252     } catch (std::out_of_range& e) {
80253       {
80254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80255       };
80256     } catch (std::exception& e) {
80257       {
80258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80259       };
80260     } catch (Dali::DaliException e) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80263       };
80264     } catch (...) {
80265       {
80266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80267       };
80268     }
80269   }
80270
80271   jresult = (void *)result;
80272   return jresult;
80273 }
80274
80275
80276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80277   void * jresult ;
80278   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80279   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80280
80281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80282   {
80283     try {
80284       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80285     } catch (std::out_of_range& e) {
80286       {
80287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80288       };
80289     } catch (std::exception& e) {
80290       {
80291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80292       };
80293     } catch (Dali::DaliException e) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80296       };
80297     } catch (...) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80300       };
80301     }
80302   }
80303
80304   jresult = (void *)result;
80305   return jresult;
80306 }
80307
80308
80309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80310   void * jresult ;
80311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80312   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80313
80314   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80315   {
80316     try {
80317       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80318     } catch (std::out_of_range& e) {
80319       {
80320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80321       };
80322     } catch (std::exception& e) {
80323       {
80324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80325       };
80326     } catch (Dali::DaliException e) {
80327       {
80328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80329       };
80330     } catch (...) {
80331       {
80332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80333       };
80334     }
80335   }
80336
80337   jresult = (void *)result;
80338   return jresult;
80339 }
80340
80341
80342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80343   void * jresult ;
80344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80345   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80346
80347   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80348   {
80349     try {
80350       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80351     } catch (std::out_of_range& e) {
80352       {
80353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80354       };
80355     } catch (std::exception& e) {
80356       {
80357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80358       };
80359     } catch (Dali::DaliException e) {
80360       {
80361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80362       };
80363     } catch (...) {
80364       {
80365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80366       };
80367     }
80368   }
80369
80370   jresult = (void *)result;
80371   return jresult;
80372 }
80373
80374
80375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80376   void * jresult ;
80377   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80378   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80379
80380   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80381   {
80382     try {
80383       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80384     } catch (std::out_of_range& e) {
80385       {
80386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80387       };
80388     } catch (std::exception& e) {
80389       {
80390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80391       };
80392     } catch (Dali::DaliException e) {
80393       {
80394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80395       };
80396     } catch (...) {
80397       {
80398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80399       };
80400     }
80401   }
80402
80403   jresult = (void *)result;
80404   return jresult;
80405 }
80406
80407
80408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80409   void * jresult ;
80410   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80411   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80412
80413   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80414   {
80415     try {
80416       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80417     } catch (std::out_of_range& e) {
80418       {
80419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80420       };
80421     } catch (std::exception& e) {
80422       {
80423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80424       };
80425     } catch (Dali::DaliException e) {
80426       {
80427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80428       };
80429     } catch (...) {
80430       {
80431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80432       };
80433     }
80434   }
80435
80436   jresult = (void *)result;
80437   return jresult;
80438 }
80439
80440
80441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80442   void * jresult ;
80443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80444   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80445
80446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80447   {
80448     try {
80449       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80450     } catch (std::out_of_range& e) {
80451       {
80452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80453       };
80454     } catch (std::exception& e) {
80455       {
80456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80457       };
80458     } catch (Dali::DaliException e) {
80459       {
80460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80461       };
80462     } catch (...) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80465       };
80466     }
80467   }
80468
80469   jresult = (void *)result;
80470   return jresult;
80471 }
80472
80473
80474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80475   void * jresult ;
80476   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80477   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80478
80479   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80480   {
80481     try {
80482       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80483     } catch (std::out_of_range& e) {
80484       {
80485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80486       };
80487     } catch (std::exception& e) {
80488       {
80489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80490       };
80491     } catch (Dali::DaliException e) {
80492       {
80493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80494       };
80495     } catch (...) {
80496       {
80497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80498       };
80499     }
80500   }
80501
80502   jresult = (void *)result;
80503   return jresult;
80504 }
80505
80506
80507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80508   void * jresult ;
80509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80510   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80511
80512   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80513   {
80514     try {
80515       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80516     } catch (std::out_of_range& e) {
80517       {
80518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (std::exception& e) {
80521       {
80522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80523       };
80524     } catch (Dali::DaliException e) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80527       };
80528     } catch (...) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80531       };
80532     }
80533   }
80534
80535   jresult = (void *)result;
80536   return jresult;
80537 }
80538
80539
80540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80541   void * jresult ;
80542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80543   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80544
80545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80546   {
80547     try {
80548       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80549     } catch (std::out_of_range& e) {
80550       {
80551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (std::exception& e) {
80554       {
80555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80556       };
80557     } catch (Dali::DaliException e) {
80558       {
80559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80560       };
80561     } catch (...) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80564       };
80565     }
80566   }
80567
80568   jresult = (void *)result;
80569   return jresult;
80570 }
80571
80572
80573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80574   void * jresult ;
80575   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80576   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80577
80578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80579   {
80580     try {
80581       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80597       };
80598     }
80599   }
80600
80601   jresult = (void *)result;
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80607   void * jresult ;
80608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80609   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80610
80611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80612   {
80613     try {
80614       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80622       };
80623     } catch (Dali::DaliException e) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80626       };
80627     } catch (...) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80630       };
80631     }
80632   }
80633
80634   jresult = (void *)result;
80635   return jresult;
80636 }
80637
80638
80639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80640   void * jresult ;
80641   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80642   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80643
80644   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80645   {
80646     try {
80647       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80648     } catch (std::out_of_range& e) {
80649       {
80650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80651       };
80652     } catch (std::exception& e) {
80653       {
80654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80655       };
80656     } catch (Dali::DaliException e) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80659       };
80660     } catch (...) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80663       };
80664     }
80665   }
80666
80667   jresult = (void *)result;
80668   return jresult;
80669 }
80670
80671
80672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80673   void * jresult ;
80674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80675   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80676
80677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80678   {
80679     try {
80680       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80681     } catch (std::out_of_range& e) {
80682       {
80683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80684       };
80685     } catch (std::exception& e) {
80686       {
80687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80688       };
80689     } catch (Dali::DaliException e) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80692       };
80693     } catch (...) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80696       };
80697     }
80698   }
80699
80700   jresult = (void *)result;
80701   return jresult;
80702 }
80703
80704
80705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80706   void * jresult ;
80707   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80708   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80709
80710   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80711   {
80712     try {
80713       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80714     } catch (std::out_of_range& e) {
80715       {
80716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80717       };
80718     } catch (std::exception& e) {
80719       {
80720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80721       };
80722     } catch (Dali::DaliException e) {
80723       {
80724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80725       };
80726     } catch (...) {
80727       {
80728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80729       };
80730     }
80731   }
80732
80733   jresult = (void *)result;
80734   return jresult;
80735 }
80736
80737
80738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80739   void * jresult ;
80740   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80741   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80742
80743   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80744   {
80745     try {
80746       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80747     } catch (std::out_of_range& e) {
80748       {
80749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80750       };
80751     } catch (std::exception& e) {
80752       {
80753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80754       };
80755     } catch (Dali::DaliException e) {
80756       {
80757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80758       };
80759     } catch (...) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80762       };
80763     }
80764   }
80765
80766   jresult = (void *)result;
80767   return jresult;
80768 }
80769
80770
80771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80772   void * jresult ;
80773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80774   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80775
80776   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80777   {
80778     try {
80779       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80780     } catch (std::out_of_range& e) {
80781       {
80782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80783       };
80784     } catch (std::exception& e) {
80785       {
80786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80787       };
80788     } catch (Dali::DaliException e) {
80789       {
80790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80791       };
80792     } catch (...) {
80793       {
80794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80795       };
80796     }
80797   }
80798
80799   jresult = (void *)result;
80800   return jresult;
80801 }
80802
80803
80804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80805   void * jresult ;
80806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80807   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80808
80809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80810   {
80811     try {
80812       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80813     } catch (std::out_of_range& e) {
80814       {
80815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80816       };
80817     } catch (std::exception& e) {
80818       {
80819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80820       };
80821     } catch (Dali::DaliException e) {
80822       {
80823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80824       };
80825     } catch (...) {
80826       {
80827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80828       };
80829     }
80830   }
80831
80832   jresult = (void *)result;
80833   return jresult;
80834 }
80835
80836
80837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80838   void * jresult ;
80839   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80840   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80841
80842   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80843   {
80844     try {
80845       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80846     } catch (std::out_of_range& e) {
80847       {
80848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80849       };
80850     } catch (std::exception& e) {
80851       {
80852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80853       };
80854     } catch (Dali::DaliException e) {
80855       {
80856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80857       };
80858     } catch (...) {
80859       {
80860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80861       };
80862     }
80863   }
80864
80865   jresult = (void *)result;
80866   return jresult;
80867 }
80868
80869
80870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80871   void * jresult ;
80872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80873   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80874
80875   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80876   {
80877     try {
80878       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80879     } catch (std::out_of_range& e) {
80880       {
80881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80882       };
80883     } catch (std::exception& e) {
80884       {
80885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80886       };
80887     } catch (Dali::DaliException e) {
80888       {
80889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80894       };
80895     }
80896   }
80897
80898   jresult = (void *)result;
80899   return jresult;
80900 }
80901
80902
80903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80904   void * jresult ;
80905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80906   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80907
80908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80909   {
80910     try {
80911       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80912     } catch (std::out_of_range& e) {
80913       {
80914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80915       };
80916     } catch (std::exception& e) {
80917       {
80918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80919       };
80920     } catch (Dali::DaliException e) {
80921       {
80922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80923       };
80924     } catch (...) {
80925       {
80926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80927       };
80928     }
80929   }
80930
80931   jresult = (void *)result;
80932   return jresult;
80933 }
80934
80935
80936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80937   void * jresult ;
80938   Dali::Toolkit::StyleManager *result = 0 ;
80939
80940   {
80941     try {
80942       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80943     } catch (std::out_of_range& e) {
80944       {
80945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (std::exception& e) {
80948       {
80949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (Dali::DaliException e) {
80952       {
80953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80954       };
80955     } catch (...) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80958       };
80959     }
80960   }
80961
80962   jresult = (void *)result;
80963   return jresult;
80964 }
80965
80966
80967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80968   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80969
80970   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80971   {
80972     try {
80973       delete arg1;
80974     } catch (std::out_of_range& e) {
80975       {
80976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80977       };
80978     } catch (std::exception& e) {
80979       {
80980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80981       };
80982     } catch (Dali::DaliException e) {
80983       {
80984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80985       };
80986     } catch (...) {
80987       {
80988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80989       };
80990     }
80991   }
80992
80993 }
80994
80995
80996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80997   void * jresult ;
80998   Dali::Toolkit::StyleManager result;
80999
81000   {
81001     try {
81002       result = Dali::Toolkit::StyleManager::Get();
81003     } catch (std::out_of_range& e) {
81004       {
81005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (std::exception& e) {
81008       {
81009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81010       };
81011     } catch (Dali::DaliException e) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81014       };
81015     } catch (...) {
81016       {
81017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81018       };
81019     }
81020   }
81021
81022   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81023   return jresult;
81024 }
81025
81026
81027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81028   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81029   std::string *arg2 = 0 ;
81030
81031   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81032   if (!jarg2) {
81033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81034     return ;
81035   }
81036   std::string arg2_str(jarg2);
81037   arg2 = &arg2_str;
81038   {
81039     try {
81040       (arg1)->ApplyTheme((std::string const &)*arg2);
81041     } catch (std::out_of_range& e) {
81042       {
81043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81044       };
81045     } catch (std::exception& e) {
81046       {
81047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81048       };
81049     } catch (Dali::DaliException e) {
81050       {
81051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81052       };
81053     } catch (...) {
81054       {
81055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81056       };
81057     }
81058   }
81059
81060
81061   //argout typemap for const std::string&
81062
81063 }
81064
81065
81066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81067   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81068
81069   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81070   {
81071     try {
81072       (arg1)->ApplyDefaultTheme();
81073     } catch (std::out_of_range& e) {
81074       {
81075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81076       };
81077     } catch (std::exception& e) {
81078       {
81079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81080       };
81081     } catch (Dali::DaliException e) {
81082       {
81083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81084       };
81085     } catch (...) {
81086       {
81087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81088       };
81089     }
81090   }
81091
81092 }
81093
81094
81095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81096   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81097   std::string *arg2 = 0 ;
81098   Dali::Property::Value *arg3 = 0 ;
81099
81100   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81101   if (!jarg2) {
81102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81103     return ;
81104   }
81105   std::string arg2_str(jarg2);
81106   arg2 = &arg2_str;
81107   arg3 = (Dali::Property::Value *)jarg3;
81108   if (!arg3) {
81109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81110     return ;
81111   }
81112   {
81113     try {
81114       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81115     } catch (std::out_of_range& e) {
81116       {
81117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81118       };
81119     } catch (std::exception& e) {
81120       {
81121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81122       };
81123     } catch (Dali::DaliException e) {
81124       {
81125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81126       };
81127     } catch (...) {
81128       {
81129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81130       };
81131     }
81132   }
81133
81134
81135   //argout typemap for const std::string&
81136
81137 }
81138
81139
81140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81141   unsigned int jresult ;
81142   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81143   std::string *arg2 = 0 ;
81144   Dali::Property::Value *arg3 = 0 ;
81145   bool result;
81146
81147   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81148   if (!jarg2) {
81149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81150     return 0;
81151   }
81152   std::string arg2_str(jarg2);
81153   arg2 = &arg2_str;
81154   arg3 = (Dali::Property::Value *)jarg3;
81155   if (!arg3) {
81156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81157     return 0;
81158   }
81159   {
81160     try {
81161       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81162     } catch (std::out_of_range& e) {
81163       {
81164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81165       };
81166     } catch (std::exception& e) {
81167       {
81168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81169       };
81170     } catch (Dali::DaliException e) {
81171       {
81172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81173       };
81174     } catch (...) {
81175       {
81176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81177       };
81178     }
81179   }
81180
81181   jresult = result;
81182
81183   //argout typemap for const std::string&
81184
81185   return jresult;
81186 }
81187
81188
81189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81190   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81191   Dali::Toolkit::Control arg2 ;
81192   std::string *arg3 = 0 ;
81193   std::string *arg4 = 0 ;
81194   Dali::Toolkit::Control *argp2 ;
81195
81196   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81197   argp2 = (Dali::Toolkit::Control *)jarg2;
81198   if (!argp2) {
81199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81200     return ;
81201   }
81202   arg2 = *argp2;
81203   if (!jarg3) {
81204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81205     return ;
81206   }
81207   std::string arg3_str(jarg3);
81208   arg3 = &arg3_str;
81209   if (!jarg4) {
81210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81211     return ;
81212   }
81213   std::string arg4_str(jarg4);
81214   arg4 = &arg4_str;
81215   {
81216     try {
81217       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81218     } catch (std::out_of_range& e) {
81219       {
81220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81221       };
81222     } catch (std::exception& e) {
81223       {
81224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81225       };
81226     } catch (Dali::DaliException e) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81229       };
81230     } catch (...) {
81231       {
81232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81233       };
81234     }
81235   }
81236
81237
81238   //argout typemap for const std::string&
81239
81240
81241   //argout typemap for const std::string&
81242
81243 }
81244
81245
81246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81247   void * jresult ;
81248   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81249   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81250
81251   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81252   {
81253     try {
81254       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81255     } catch (std::out_of_range& e) {
81256       {
81257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (std::exception& e) {
81260       {
81261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81262       };
81263     } catch (Dali::DaliException e) {
81264       {
81265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81266       };
81267     } catch (...) {
81268       {
81269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81270       };
81271     }
81272   }
81273
81274   jresult = (void *)result;
81275   return jresult;
81276 }
81277
81278
81279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81280   int jresult ;
81281   int result;
81282
81283   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81284   jresult = (int)result;
81285   return jresult;
81286 }
81287
81288
81289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81290   int jresult ;
81291   int result;
81292
81293   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81294   jresult = (int)result;
81295   return jresult;
81296 }
81297
81298
81299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81300   int jresult ;
81301   int result;
81302
81303   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81304   jresult = (int)result;
81305   return jresult;
81306 }
81307
81308
81309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81310   int jresult ;
81311   int result;
81312
81313   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81314   jresult = (int)result;
81315   return jresult;
81316 }
81317
81318
81319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81320   int jresult ;
81321   int result;
81322
81323   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81324   jresult = (int)result;
81325   return jresult;
81326 }
81327
81328
81329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81330   int jresult ;
81331   int result;
81332
81333   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81334   jresult = (int)result;
81335   return jresult;
81336 }
81337
81338
81339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81340   int jresult ;
81341   int result;
81342
81343   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81344   jresult = (int)result;
81345   return jresult;
81346 }
81347
81348
81349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81350   int jresult ;
81351   int result;
81352
81353   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81354   jresult = (int)result;
81355   return jresult;
81356 }
81357
81358
81359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81360   int jresult ;
81361   int result;
81362
81363   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81364   jresult = (int)result;
81365   return jresult;
81366 }
81367
81368
81369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81370   int jresult ;
81371   int result;
81372
81373   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81374   jresult = (int)result;
81375   return jresult;
81376 }
81377
81378
81379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81380   int jresult ;
81381   int result;
81382
81383   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81384   jresult = (int)result;
81385   return jresult;
81386 }
81387
81388
81389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81390   int jresult ;
81391   int result;
81392
81393   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81394   jresult = (int)result;
81395   return jresult;
81396 }
81397
81398
81399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81400   int jresult ;
81401   int result;
81402
81403   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81404   jresult = (int)result;
81405   return jresult;
81406 }
81407
81408
81409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81410   int jresult ;
81411   int result;
81412
81413   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81414   jresult = (int)result;
81415   return jresult;
81416 }
81417
81418
81419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81420   int jresult ;
81421   int result;
81422
81423   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81424   jresult = (int)result;
81425   return jresult;
81426 }
81427
81428
81429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81430   void * jresult ;
81431   Dali::Toolkit::Slider::Property *result = 0 ;
81432
81433   {
81434     try {
81435       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81436     } catch (std::out_of_range& e) {
81437       {
81438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81439       };
81440     } catch (std::exception& e) {
81441       {
81442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81443       };
81444     } catch (Dali::DaliException e) {
81445       {
81446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81447       };
81448     } catch (...) {
81449       {
81450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81451       };
81452     }
81453   }
81454
81455   jresult = (void *)result;
81456   return jresult;
81457 }
81458
81459
81460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81461   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81462
81463   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81464   {
81465     try {
81466       delete arg1;
81467     } catch (std::out_of_range& e) {
81468       {
81469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81470       };
81471     } catch (std::exception& e) {
81472       {
81473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81474       };
81475     } catch (Dali::DaliException e) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81478       };
81479     } catch (...) {
81480       {
81481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81482       };
81483     }
81484   }
81485
81486 }
81487
81488
81489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81490   void * jresult ;
81491   Dali::Toolkit::Slider result;
81492
81493   {
81494     try {
81495       result = Dali::Toolkit::Slider::New();
81496     } catch (std::out_of_range& e) {
81497       {
81498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81499       };
81500     } catch (std::exception& e) {
81501       {
81502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81503       };
81504     } catch (Dali::DaliException e) {
81505       {
81506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81507       };
81508     } catch (...) {
81509       {
81510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81511       };
81512     }
81513   }
81514
81515   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81521   void * jresult ;
81522   Dali::Toolkit::Slider *result = 0 ;
81523
81524   {
81525     try {
81526       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81527     } catch (std::out_of_range& e) {
81528       {
81529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81530       };
81531     } catch (std::exception& e) {
81532       {
81533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81534       };
81535     } catch (Dali::DaliException e) {
81536       {
81537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81538       };
81539     } catch (...) {
81540       {
81541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81542       };
81543     }
81544   }
81545
81546   jresult = (void *)result;
81547   return jresult;
81548 }
81549
81550
81551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81552   void * jresult ;
81553   Dali::Toolkit::Slider *arg1 = 0 ;
81554   Dali::Toolkit::Slider *result = 0 ;
81555
81556   arg1 = (Dali::Toolkit::Slider *)jarg1;
81557   if (!arg1) {
81558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81559     return 0;
81560   }
81561   {
81562     try {
81563       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81564     } catch (std::out_of_range& e) {
81565       {
81566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81567       };
81568     } catch (std::exception& e) {
81569       {
81570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81571       };
81572     } catch (Dali::DaliException e) {
81573       {
81574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81575       };
81576     } catch (...) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81579       };
81580     }
81581   }
81582
81583   jresult = (void *)result;
81584   return jresult;
81585 }
81586
81587
81588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81589   void * jresult ;
81590   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81591   Dali::Toolkit::Slider *arg2 = 0 ;
81592   Dali::Toolkit::Slider *result = 0 ;
81593
81594   arg1 = (Dali::Toolkit::Slider *)jarg1;
81595   arg2 = (Dali::Toolkit::Slider *)jarg2;
81596   if (!arg2) {
81597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81598     return 0;
81599   }
81600   {
81601     try {
81602       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81610       };
81611     } catch (Dali::DaliException e) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81614       };
81615     } catch (...) {
81616       {
81617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81618       };
81619     }
81620   }
81621
81622   jresult = (void *)result;
81623   return jresult;
81624 }
81625
81626
81627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81628   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81629
81630   arg1 = (Dali::Toolkit::Slider *)jarg1;
81631   {
81632     try {
81633       delete arg1;
81634     } catch (std::out_of_range& e) {
81635       {
81636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81637       };
81638     } catch (std::exception& e) {
81639       {
81640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81641       };
81642     } catch (Dali::DaliException e) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81645       };
81646     } catch (...) {
81647       {
81648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81649       };
81650     }
81651   }
81652
81653 }
81654
81655
81656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81657   void * jresult ;
81658   Dali::BaseHandle arg1 ;
81659   Dali::BaseHandle *argp1 ;
81660   Dali::Toolkit::Slider result;
81661
81662   argp1 = (Dali::BaseHandle *)jarg1;
81663   if (!argp1) {
81664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81665     return 0;
81666   }
81667   arg1 = *argp1;
81668   {
81669     try {
81670       result = Dali::Toolkit::Slider::DownCast(arg1);
81671     } catch (std::out_of_range& e) {
81672       {
81673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81674       };
81675     } catch (std::exception& e) {
81676       {
81677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81678       };
81679     } catch (Dali::DaliException e) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81682       };
81683     } catch (...) {
81684       {
81685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81686       };
81687     }
81688   }
81689
81690   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81691   return jresult;
81692 }
81693
81694
81695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81696   void * jresult ;
81697   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81698   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81699
81700   arg1 = (Dali::Toolkit::Slider *)jarg1;
81701   {
81702     try {
81703       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81719       };
81720     }
81721   }
81722
81723   jresult = (void *)result;
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81729   void * jresult ;
81730   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81731   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81732
81733   arg1 = (Dali::Toolkit::Slider *)jarg1;
81734   {
81735     try {
81736       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81737     } catch (std::out_of_range& e) {
81738       {
81739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81740       };
81741     } catch (std::exception& e) {
81742       {
81743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81744       };
81745     } catch (Dali::DaliException e) {
81746       {
81747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81748       };
81749     } catch (...) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81752       };
81753     }
81754   }
81755
81756   jresult = (void *)result;
81757   return jresult;
81758 }
81759
81760
81761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81762   void * jresult ;
81763   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81764   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81765
81766   arg1 = (Dali::Toolkit::Slider *)jarg1;
81767   {
81768     try {
81769       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81770     } catch (std::out_of_range& e) {
81771       {
81772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81773       };
81774     } catch (std::exception& e) {
81775       {
81776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81777       };
81778     } catch (Dali::DaliException e) {
81779       {
81780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81781       };
81782     } catch (...) {
81783       {
81784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81785       };
81786     }
81787   }
81788
81789   jresult = (void *)result;
81790   return jresult;
81791 }
81792
81793
81794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81795   int jresult ;
81796   int result;
81797
81798   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81799   jresult = (int)result;
81800   return jresult;
81801 }
81802
81803
81804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81805   int jresult ;
81806   int result;
81807
81808   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81809   jresult = (int)result;
81810   return jresult;
81811 }
81812
81813
81814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81815   int jresult ;
81816   int result;
81817
81818   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81819   jresult = (int)result;
81820   return jresult;
81821 }
81822
81823
81824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81825   int jresult ;
81826   int result;
81827
81828   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81829   jresult = (int)result;
81830   return jresult;
81831 }
81832
81833
81834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81835   int result;
81836
81837   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81838
81839   return result;
81840 }
81841
81842
81843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81844   void * jresult ;
81845   Dali::Toolkit::VideoView::Property *result = 0 ;
81846
81847   {
81848     try {
81849       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81850     } catch (std::out_of_range& e) {
81851       {
81852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81853       };
81854     } catch (std::exception& e) {
81855       {
81856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81857       };
81858     } catch (Dali::DaliException e) {
81859       {
81860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81861       };
81862     } catch (...) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81865       };
81866     }
81867   }
81868
81869   jresult = (void *)result;
81870   return jresult;
81871 }
81872
81873
81874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81875   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81876
81877   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81878   {
81879     try {
81880       delete arg1;
81881     } catch (std::out_of_range& e) {
81882       {
81883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81884       };
81885     } catch (std::exception& e) {
81886       {
81887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81888       };
81889     } catch (Dali::DaliException e) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81896       };
81897     }
81898   }
81899
81900 }
81901
81902
81903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81904   void * jresult ;
81905   Dali::Toolkit::VideoView result;
81906
81907   {
81908     try {
81909       result = Dali::Toolkit::VideoView::New();
81910     } catch (std::out_of_range& e) {
81911       {
81912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81913       };
81914     } catch (std::exception& e) {
81915       {
81916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81917       };
81918     } catch (Dali::DaliException e) {
81919       {
81920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81921       };
81922     } catch (...) {
81923       {
81924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81925       };
81926     }
81927   }
81928
81929   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81930   return jresult;
81931 }
81932
81933
81934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81935   void * jresult ;
81936   std::string *arg1 = 0 ;
81937   Dali::Toolkit::VideoView result;
81938
81939   if (!jarg1) {
81940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81941     return 0;
81942   }
81943   std::string arg1_str(jarg1);
81944   arg1 = &arg1_str;
81945   {
81946     try {
81947       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81948     } catch (std::out_of_range& e) {
81949       {
81950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81951       };
81952     } catch (std::exception& e) {
81953       {
81954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81955       };
81956     } catch (Dali::DaliException e) {
81957       {
81958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81959       };
81960     } catch (...) {
81961       {
81962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81963       };
81964     }
81965   }
81966
81967   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81968
81969   //argout typemap for const std::string&
81970
81971   return jresult;
81972 }
81973
81974
81975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81976   void * jresult ;
81977   Dali::Toolkit::VideoView result;
81978   {
81979     try {
81980       result = Dali::Toolkit::VideoView::New(swCodec);
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (Dali::DaliException e) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81992       };
81993     } catch (...) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81996       };
81997     }
81998   }
81999
82000   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82001
82002   //argout typemap for const std::string&
82003
82004   return jresult;
82005 }
82006
82007
82008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82009   void * jresult ;
82010   std::string *arg1 = 0 ;
82011   Dali::Toolkit::VideoView result;
82012
82013   if (!jarg1) {
82014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82015     return 0;
82016   }
82017   std::string arg1_str(jarg1);
82018   arg1 = &arg1_str;
82019   {
82020     try {
82021       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
82022     } catch (std::out_of_range& e) {
82023       {
82024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82025       };
82026     } catch (std::exception& e) {
82027       {
82028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82029       };
82030     } catch (Dali::DaliException e) {
82031       {
82032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82033       };
82034     } catch (...) {
82035       {
82036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82037       };
82038     }
82039   }
82040
82041   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82042
82043   //argout typemap for const std::string&
82044
82045   return jresult;
82046 }
82047
82048
82049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82050   void * jresult ;
82051   Dali::Toolkit::VideoView *result = 0 ;
82052
82053   {
82054     try {
82055       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82056     } catch (std::out_of_range& e) {
82057       {
82058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82059       };
82060     } catch (std::exception& e) {
82061       {
82062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82063       };
82064     } catch (Dali::DaliException e) {
82065       {
82066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82067       };
82068     } catch (...) {
82069       {
82070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82071       };
82072     }
82073   }
82074
82075   jresult = (void *)result;
82076   return jresult;
82077 }
82078
82079
82080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82081   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82082
82083   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82084   {
82085     try {
82086       delete arg1;
82087     } catch (std::out_of_range& e) {
82088       {
82089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82090       };
82091     } catch (std::exception& e) {
82092       {
82093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82094       };
82095     } catch (Dali::DaliException e) {
82096       {
82097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82098       };
82099     } catch (...) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82102       };
82103     }
82104   }
82105
82106 }
82107
82108
82109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82110   void * jresult ;
82111   Dali::Toolkit::VideoView *arg1 = 0 ;
82112   Dali::Toolkit::VideoView *result = 0 ;
82113
82114   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82115   if (!arg1) {
82116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82117     return 0;
82118   }
82119   {
82120     try {
82121       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
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 = (void *)result;
82142   return jresult;
82143 }
82144
82145
82146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82147   void * jresult ;
82148   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82149   Dali::Toolkit::VideoView *arg2 = 0 ;
82150   Dali::Toolkit::VideoView *result = 0 ;
82151
82152   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82153   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82154   if (!arg2) {
82155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82156     return 0;
82157   }
82158   {
82159     try {
82160       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (Dali::DaliException e) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82172       };
82173     } catch (...) {
82174       {
82175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82176       };
82177     }
82178   }
82179
82180   jresult = (void *)result;
82181   return jresult;
82182 }
82183
82184
82185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82186   void * jresult ;
82187   Dali::BaseHandle arg1 ;
82188   Dali::BaseHandle *argp1 ;
82189   Dali::Toolkit::VideoView result;
82190
82191   argp1 = (Dali::BaseHandle *)jarg1;
82192   if (!argp1) {
82193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82194     return 0;
82195   }
82196   arg1 = *argp1;
82197   {
82198     try {
82199       result = Dali::Toolkit::VideoView::DownCast(arg1);
82200     } catch (std::out_of_range& e) {
82201       {
82202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82203       };
82204     } catch (std::exception& e) {
82205       {
82206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82207       };
82208     } catch (Dali::DaliException e) {
82209       {
82210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82211       };
82212     } catch (...) {
82213       {
82214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82215       };
82216     }
82217   }
82218
82219   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82220   return jresult;
82221 }
82222
82223
82224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82225   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82226
82227   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82228   {
82229     try {
82230       (arg1)->Play();
82231     } catch (std::out_of_range& e) {
82232       {
82233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82234       };
82235     } catch (std::exception& e) {
82236       {
82237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82238       };
82239     } catch (Dali::DaliException e) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82242       };
82243     } catch (...) {
82244       {
82245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82246       };
82247     }
82248   }
82249
82250 }
82251
82252
82253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82254   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82255
82256   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82257   {
82258     try {
82259       (arg1)->Pause();
82260     } catch (std::out_of_range& e) {
82261       {
82262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82263       };
82264     } catch (std::exception& e) {
82265       {
82266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82267       };
82268     } catch (Dali::DaliException e) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82271       };
82272     } catch (...) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82275       };
82276     }
82277   }
82278
82279 }
82280
82281
82282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82283   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82284
82285   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82286   {
82287     try {
82288       (arg1)->Stop();
82289     } catch (std::out_of_range& e) {
82290       {
82291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82292       };
82293     } catch (std::exception& e) {
82294       {
82295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82296       };
82297     } catch (Dali::DaliException e) {
82298       {
82299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82300       };
82301     } catch (...) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82304       };
82305     }
82306   }
82307
82308 }
82309
82310
82311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82312   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82313   int arg2 ;
82314
82315   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82316   arg2 = (int)jarg2;
82317   {
82318     try {
82319       (arg1)->Forward(arg2);
82320     } catch (std::out_of_range& e) {
82321       {
82322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82323       };
82324     } catch (std::exception& e) {
82325       {
82326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82327       };
82328     } catch (Dali::DaliException e) {
82329       {
82330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82331       };
82332     } catch (...) {
82333       {
82334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82335       };
82336     }
82337   }
82338
82339 }
82340
82341
82342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82343   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82344   int arg2 ;
82345
82346   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82347   arg2 = (int)jarg2;
82348   {
82349     try {
82350       (arg1)->Backward(arg2);
82351     } catch (std::out_of_range& e) {
82352       {
82353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82354       };
82355     } catch (std::exception& e) {
82356       {
82357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82358       };
82359     } catch (Dali::DaliException e) {
82360       {
82361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82362       };
82363     } catch (...) {
82364       {
82365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82366       };
82367     }
82368   }
82369
82370 }
82371
82372
82373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82374   void * jresult ;
82375   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82376   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82377
82378   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82379   {
82380     try {
82381       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82389       };
82390     } catch (Dali::DaliException e) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82397       };
82398     }
82399   }
82400
82401   jresult = (void *)result;
82402   return jresult;
82403 }
82404
82405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82406 {
82407   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82408   if( arg1 == nullptr )
82409   {
82410     DALI_LOG_ERROR("VideoView is nullptr!");
82411     return nullptr;
82412   }
82413   void * ret = nullptr;
82414   {
82415     try{
82416
82417       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82418       ret = Dali::AnyCast< void * >( result );
82419
82420     } catch (std::out_of_range& e) {
82421       {
82422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82423       };
82424     } catch (std::exception& e) {
82425       {
82426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82427       };
82428     } catch (Dali::DaliException e) {
82429       {
82430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82431       };
82432     } catch (...) {
82433       {
82434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82435       };
82436     }
82437   }
82438   return ret;
82439 }
82440
82441
82442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82443   int jresult ;
82444   int result;
82445
82446   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82447   jresult = (int)result;
82448   return jresult;
82449 }
82450
82451
82452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82453   int jresult ;
82454   int result;
82455
82456   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82457   jresult = (int)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82463   int jresult ;
82464   int result;
82465
82466   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82467   jresult = (int)result;
82468   return jresult;
82469 }
82470
82471
82472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82473   int jresult ;
82474   int result;
82475
82476   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82477   jresult = (int)result;
82478   return jresult;
82479 }
82480
82481
82482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82483   int jresult ;
82484   int result;
82485
82486   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82487   jresult = (int)result;
82488   return jresult;
82489 }
82490
82491
82492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82493   int jresult ;
82494   int result;
82495
82496   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82497   jresult = (int)result;
82498   return jresult;
82499 }
82500
82501
82502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82503   int jresult ;
82504   int result;
82505
82506   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82507   jresult = (int)result;
82508   return jresult;
82509 }
82510
82511
82512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82513   int jresult ;
82514   int result;
82515
82516   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82517   jresult = (int)result;
82518   return jresult;
82519 }
82520
82521
82522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82523   int jresult ;
82524   int result;
82525
82526   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82527   jresult = (int)result;
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82533   int jresult ;
82534   int result;
82535
82536   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82537   jresult = (int)result;
82538   return jresult;
82539 }
82540
82541
82542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82543   int jresult ;
82544   int result;
82545
82546   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82547   jresult = (int)result;
82548   return jresult;
82549 }
82550
82551
82552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82553   int jresult ;
82554   int result;
82555
82556   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82557   jresult = (int)result;
82558   return jresult;
82559 }
82560
82561
82562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82563   int jresult ;
82564   int result;
82565
82566   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82567   jresult = (int)result;
82568   return jresult;
82569 }
82570
82571
82572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82573   int jresult ;
82574   int result;
82575
82576   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82577   jresult = (int)result;
82578   return jresult;
82579 }
82580
82581
82582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82583   int jresult ;
82584   int result;
82585
82586   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82587   jresult = (int)result;
82588   return jresult;
82589 }
82590
82591
82592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82593   int jresult ;
82594   int result;
82595
82596   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82597   jresult = (int)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82603   int jresult ;
82604   int result;
82605
82606   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82607   jresult = (int)result;
82608   return jresult;
82609 }
82610
82611
82612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82613   int jresult ;
82614   int result;
82615
82616   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82617   jresult = (int)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82623   int jresult ;
82624   int result;
82625
82626   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82627   jresult = (int)result;
82628   return jresult;
82629 }
82630
82631
82632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82633   int jresult ;
82634   int result;
82635
82636   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82637   jresult = (int)result;
82638   return jresult;
82639 }
82640
82641
82642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82643   int jresult ;
82644   int result;
82645
82646   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82647   jresult = (int)result;
82648   return jresult;
82649 }
82650
82651
82652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82653   void * jresult ;
82654   Dali::Toolkit::Popup::Property *result = 0 ;
82655
82656   {
82657     try {
82658       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82659     } catch (std::out_of_range& e) {
82660       {
82661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82662       };
82663     } catch (std::exception& e) {
82664       {
82665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82666       };
82667     } catch (Dali::DaliException e) {
82668       {
82669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82670       };
82671     } catch (...) {
82672       {
82673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82674       };
82675     }
82676   }
82677
82678   jresult = (void *)result;
82679   return jresult;
82680 }
82681
82682
82683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82684   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82685
82686   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82687   {
82688     try {
82689       delete arg1;
82690     } catch (std::out_of_range& e) {
82691       {
82692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82693       };
82694     } catch (std::exception& e) {
82695       {
82696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82697       };
82698     } catch (Dali::DaliException e) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82701       };
82702     } catch (...) {
82703       {
82704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82705       };
82706     }
82707   }
82708
82709 }
82710
82711
82712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82713   void * jresult ;
82714   Dali::Toolkit::Popup *result = 0 ;
82715
82716   {
82717     try {
82718       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82726       };
82727     } catch (Dali::DaliException e) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82734       };
82735     }
82736   }
82737
82738   jresult = (void *)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82744   void * jresult ;
82745   Dali::Toolkit::Popup result;
82746
82747   {
82748     try {
82749       result = Dali::Toolkit::Popup::New();
82750     } catch (std::out_of_range& e) {
82751       {
82752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82753       };
82754     } catch (std::exception& e) {
82755       {
82756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82757       };
82758     } catch (Dali::DaliException e) {
82759       {
82760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82761       };
82762     } catch (...) {
82763       {
82764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82765       };
82766     }
82767   }
82768
82769   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82770   return jresult;
82771 }
82772
82773
82774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82775   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82776
82777   arg1 = (Dali::Toolkit::Popup *)jarg1;
82778   {
82779     try {
82780       delete arg1;
82781     } catch (std::out_of_range& e) {
82782       {
82783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82784       };
82785     } catch (std::exception& e) {
82786       {
82787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82788       };
82789     } catch (Dali::DaliException e) {
82790       {
82791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82792       };
82793     } catch (...) {
82794       {
82795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82796       };
82797     }
82798   }
82799
82800 }
82801
82802
82803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82804   void * jresult ;
82805   Dali::Toolkit::Popup *arg1 = 0 ;
82806   Dali::Toolkit::Popup *result = 0 ;
82807
82808   arg1 = (Dali::Toolkit::Popup *)jarg1;
82809   if (!arg1) {
82810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82811     return 0;
82812   }
82813   {
82814     try {
82815       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82816     } catch (std::out_of_range& e) {
82817       {
82818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82819       };
82820     } catch (std::exception& e) {
82821       {
82822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82823       };
82824     } catch (Dali::DaliException e) {
82825       {
82826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82827       };
82828     } catch (...) {
82829       {
82830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82831       };
82832     }
82833   }
82834
82835   jresult = (void *)result;
82836   return jresult;
82837 }
82838
82839
82840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82841   void * jresult ;
82842   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82843   Dali::Toolkit::Popup *arg2 = 0 ;
82844   Dali::Toolkit::Popup *result = 0 ;
82845
82846   arg1 = (Dali::Toolkit::Popup *)jarg1;
82847   arg2 = (Dali::Toolkit::Popup *)jarg2;
82848   if (!arg2) {
82849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82850     return 0;
82851   }
82852   {
82853     try {
82854       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82855     } catch (std::out_of_range& e) {
82856       {
82857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (std::exception& e) {
82860       {
82861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82862       };
82863     } catch (Dali::DaliException e) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82866       };
82867     } catch (...) {
82868       {
82869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82870       };
82871     }
82872   }
82873
82874   jresult = (void *)result;
82875   return jresult;
82876 }
82877
82878
82879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82880   void * jresult ;
82881   Dali::BaseHandle arg1 ;
82882   Dali::BaseHandle *argp1 ;
82883   Dali::Toolkit::Popup result;
82884
82885   argp1 = (Dali::BaseHandle *)jarg1;
82886   if (!argp1) {
82887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82888     return 0;
82889   }
82890   arg1 = *argp1;
82891   {
82892     try {
82893       result = Dali::Toolkit::Popup::DownCast(arg1);
82894     } catch (std::out_of_range& e) {
82895       {
82896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82897       };
82898     } catch (std::exception& e) {
82899       {
82900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82901       };
82902     } catch (Dali::DaliException e) {
82903       {
82904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82905       };
82906     } catch (...) {
82907       {
82908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82909       };
82910     }
82911   }
82912
82913   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82914   return jresult;
82915 }
82916
82917
82918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82919   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82920   Dali::Actor arg2 ;
82921   Dali::Actor *argp2 ;
82922
82923   arg1 = (Dali::Toolkit::Popup *)jarg1;
82924   argp2 = (Dali::Actor *)jarg2;
82925   if (!argp2) {
82926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82927     return ;
82928   }
82929   arg2 = *argp2;
82930   {
82931     try {
82932       (arg1)->SetTitle(arg2);
82933     } catch (std::out_of_range& e) {
82934       {
82935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82936       };
82937     } catch (std::exception& e) {
82938       {
82939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82940       };
82941     } catch (Dali::DaliException e) {
82942       {
82943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82944       };
82945     } catch (...) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82948       };
82949     }
82950   }
82951
82952 }
82953
82954
82955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82956   void * jresult ;
82957   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82958   Dali::Actor result;
82959
82960   arg1 = (Dali::Toolkit::Popup *)jarg1;
82961   {
82962     try {
82963       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82964     } catch (std::out_of_range& e) {
82965       {
82966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82967       };
82968     } catch (std::exception& e) {
82969       {
82970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82971       };
82972     } catch (Dali::DaliException e) {
82973       {
82974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82975       };
82976     } catch (...) {
82977       {
82978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82979       };
82980     }
82981   }
82982
82983   jresult = new Dali::Actor((const Dali::Actor &)result);
82984   return jresult;
82985 }
82986
82987
82988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82989   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82990   Dali::Actor arg2 ;
82991   Dali::Actor *argp2 ;
82992
82993   arg1 = (Dali::Toolkit::Popup *)jarg1;
82994   argp2 = (Dali::Actor *)jarg2;
82995   if (!argp2) {
82996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82997     return ;
82998   }
82999   arg2 = *argp2;
83000   {
83001     try {
83002       (arg1)->SetContent(arg2);
83003     } catch (std::out_of_range& e) {
83004       {
83005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (std::exception& e) {
83008       {
83009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83010       };
83011     } catch (Dali::DaliException e) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83014       };
83015     } catch (...) {
83016       {
83017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83018       };
83019     }
83020   }
83021
83022 }
83023
83024
83025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83026   void * jresult ;
83027   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83028   Dali::Actor result;
83029
83030   arg1 = (Dali::Toolkit::Popup *)jarg1;
83031   {
83032     try {
83033       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83034     } catch (std::out_of_range& e) {
83035       {
83036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83037       };
83038     } catch (std::exception& e) {
83039       {
83040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83041       };
83042     } catch (Dali::DaliException e) {
83043       {
83044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83045       };
83046     } catch (...) {
83047       {
83048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83049       };
83050     }
83051   }
83052
83053   jresult = new Dali::Actor((const Dali::Actor &)result);
83054   return jresult;
83055 }
83056
83057
83058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83059   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83060   Dali::Actor arg2 ;
83061   Dali::Actor *argp2 ;
83062
83063   arg1 = (Dali::Toolkit::Popup *)jarg1;
83064   argp2 = (Dali::Actor *)jarg2;
83065   if (!argp2) {
83066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83067     return ;
83068   }
83069   arg2 = *argp2;
83070   {
83071     try {
83072       (arg1)->SetFooter(arg2);
83073     } catch (std::out_of_range& e) {
83074       {
83075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83076       };
83077     } catch (std::exception& e) {
83078       {
83079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83080       };
83081     } catch (Dali::DaliException e) {
83082       {
83083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83084       };
83085     } catch (...) {
83086       {
83087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83088       };
83089     }
83090   }
83091
83092 }
83093
83094
83095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83096   void * jresult ;
83097   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83098   Dali::Actor result;
83099
83100   arg1 = (Dali::Toolkit::Popup *)jarg1;
83101   {
83102     try {
83103       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83104     } catch (std::out_of_range& e) {
83105       {
83106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83107       };
83108     } catch (std::exception& e) {
83109       {
83110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83111       };
83112     } catch (Dali::DaliException e) {
83113       {
83114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83115       };
83116     } catch (...) {
83117       {
83118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83119       };
83120     }
83121   }
83122
83123   jresult = new Dali::Actor((const Dali::Actor &)result);
83124   return jresult;
83125 }
83126
83127
83128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83129   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83130   Dali::Toolkit::Popup::DisplayState arg2 ;
83131
83132   arg1 = (Dali::Toolkit::Popup *)jarg1;
83133   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83134   {
83135     try {
83136       (arg1)->SetDisplayState(arg2);
83137     } catch (std::out_of_range& e) {
83138       {
83139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83140       };
83141     } catch (std::exception& e) {
83142       {
83143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83144       };
83145     } catch (Dali::DaliException e) {
83146       {
83147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83148       };
83149     } catch (...) {
83150       {
83151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83152       };
83153     }
83154   }
83155
83156 }
83157
83158
83159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83160   int jresult ;
83161   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83162   Dali::Toolkit::Popup::DisplayState result;
83163
83164   arg1 = (Dali::Toolkit::Popup *)jarg1;
83165   {
83166     try {
83167       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83168     } catch (std::out_of_range& e) {
83169       {
83170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83171       };
83172     } catch (std::exception& e) {
83173       {
83174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83175       };
83176     } catch (Dali::DaliException e) {
83177       {
83178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83183       };
83184     }
83185   }
83186
83187   jresult = (int)result;
83188   return jresult;
83189 }
83190
83191
83192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83193   void * jresult ;
83194   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83195   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83196
83197   arg1 = (Dali::Toolkit::Popup *)jarg1;
83198   {
83199     try {
83200       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83201     } catch (std::out_of_range& e) {
83202       {
83203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83204       };
83205     } catch (std::exception& e) {
83206       {
83207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83208       };
83209     } catch (Dali::DaliException e) {
83210       {
83211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83212       };
83213     } catch (...) {
83214       {
83215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83216       };
83217     }
83218   }
83219
83220   jresult = (void *)result;
83221   return jresult;
83222 }
83223
83224
83225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83226   void * jresult ;
83227   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83228   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83229
83230   arg1 = (Dali::Toolkit::Popup *)jarg1;
83231   {
83232     try {
83233       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83234     } catch (std::out_of_range& e) {
83235       {
83236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83237       };
83238     } catch (std::exception& e) {
83239       {
83240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83241       };
83242     } catch (Dali::DaliException e) {
83243       {
83244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83245       };
83246     } catch (...) {
83247       {
83248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83249       };
83250     }
83251   }
83252
83253   jresult = (void *)result;
83254   return jresult;
83255 }
83256
83257
83258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83259   void * jresult ;
83260   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83261   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83262
83263   arg1 = (Dali::Toolkit::Popup *)jarg1;
83264   {
83265     try {
83266       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83267     } catch (std::out_of_range& e) {
83268       {
83269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (std::exception& e) {
83272       {
83273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83274       };
83275     } catch (Dali::DaliException e) {
83276       {
83277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83278       };
83279     } catch (...) {
83280       {
83281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83282       };
83283     }
83284   }
83285
83286   jresult = (void *)result;
83287   return jresult;
83288 }
83289
83290
83291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83292   void * jresult ;
83293   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83294   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83295
83296   arg1 = (Dali::Toolkit::Popup *)jarg1;
83297   {
83298     try {
83299       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83300     } catch (std::out_of_range& e) {
83301       {
83302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83303       };
83304     } catch (std::exception& e) {
83305       {
83306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83307       };
83308     } catch (Dali::DaliException e) {
83309       {
83310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83311       };
83312     } catch (...) {
83313       {
83314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83315       };
83316     }
83317   }
83318
83319   jresult = (void *)result;
83320   return jresult;
83321 }
83322
83323
83324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83325   void * jresult ;
83326   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83327   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83328
83329   arg1 = (Dali::Toolkit::Popup *)jarg1;
83330   {
83331     try {
83332       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83333     } catch (std::out_of_range& e) {
83334       {
83335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83336       };
83337     } catch (std::exception& e) {
83338       {
83339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (Dali::DaliException e) {
83342       {
83343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83348       };
83349     }
83350   }
83351
83352   jresult = (void *)result;
83353   return jresult;
83354 }
83355
83356
83357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83358   int jresult ;
83359   int result;
83360
83361   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83362   jresult = (int)result;
83363   return jresult;
83364 }
83365
83366
83367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83368   int jresult ;
83369   int result;
83370
83371   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83372   jresult = (int)result;
83373   return jresult;
83374 }
83375
83376
83377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83378   int jresult ;
83379   int result;
83380
83381   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83382   jresult = (int)result;
83383   return jresult;
83384 }
83385
83386
83387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83388   int jresult ;
83389   int result;
83390
83391   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83392   jresult = (int)result;
83393   return jresult;
83394 }
83395
83396
83397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83398   int jresult ;
83399   int result;
83400
83401   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83402   jresult = (int)result;
83403   return jresult;
83404 }
83405
83406
83407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83408   int jresult ;
83409   int result;
83410
83411   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83412   jresult = (int)result;
83413   return jresult;
83414 }
83415
83416
83417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83418   int jresult ;
83419   int result;
83420
83421   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83422   jresult = (int)result;
83423   return jresult;
83424 }
83425
83426
83427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83428   int jresult ;
83429   int result;
83430
83431   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83432   jresult = (int)result;
83433   return jresult;
83434 }
83435
83436
83437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83438   int jresult ;
83439   int result;
83440
83441   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83442   jresult = (int)result;
83443   return jresult;
83444 }
83445
83446
83447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83448   void * jresult ;
83449   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83450
83451   {
83452     try {
83453       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83454     } catch (std::out_of_range& e) {
83455       {
83456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83457       };
83458     } catch (std::exception& e) {
83459       {
83460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83461       };
83462     } catch (Dali::DaliException e) {
83463       {
83464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83465       };
83466     } catch (...) {
83467       {
83468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83469       };
83470     }
83471   }
83472
83473   jresult = (void *)result;
83474   return jresult;
83475 }
83476
83477
83478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83479   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83480
83481   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83482   {
83483     try {
83484       delete arg1;
83485     } catch (std::out_of_range& e) {
83486       {
83487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83488       };
83489     } catch (std::exception& e) {
83490       {
83491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83492       };
83493     } catch (Dali::DaliException e) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83496       };
83497     } catch (...) {
83498       {
83499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83500       };
83501     }
83502   }
83503
83504 }
83505
83506
83507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83508   void * jresult ;
83509   Dali::Toolkit::ProgressBar result;
83510
83511   {
83512     try {
83513       result = Dali::Toolkit::ProgressBar::New();
83514     } catch (std::out_of_range& e) {
83515       {
83516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83517       };
83518     } catch (std::exception& e) {
83519       {
83520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83521       };
83522     } catch (Dali::DaliException e) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83525       };
83526     } catch (...) {
83527       {
83528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83529       };
83530     }
83531   }
83532
83533   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83534   return jresult;
83535 }
83536
83537
83538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83539   void * jresult ;
83540   Dali::Toolkit::ProgressBar *result = 0 ;
83541
83542   {
83543     try {
83544       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
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 void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83570   void * jresult ;
83571   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83572   Dali::Toolkit::ProgressBar *result = 0 ;
83573
83574   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83575   if (!arg1) {
83576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83577     return 0;
83578   }
83579   {
83580     try {
83581       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83582     } catch (std::out_of_range& e) {
83583       {
83584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83585       };
83586     } catch (std::exception& e) {
83587       {
83588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83589       };
83590     } catch (Dali::DaliException e) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83593       };
83594     } catch (...) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83597       };
83598     }
83599   }
83600
83601   jresult = (void *)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83607   void * jresult ;
83608   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83609   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83610   Dali::Toolkit::ProgressBar *result = 0 ;
83611
83612   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83613   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83614   if (!arg2) {
83615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83616     return 0;
83617   }
83618   {
83619     try {
83620       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83621     } catch (std::out_of_range& e) {
83622       {
83623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (std::exception& e) {
83626       {
83627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83628       };
83629     } catch (Dali::DaliException e) {
83630       {
83631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83632       };
83633     } catch (...) {
83634       {
83635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83636       };
83637     }
83638   }
83639
83640   jresult = (void *)result;
83641   return jresult;
83642 }
83643
83644
83645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83646   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83647
83648   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83649   {
83650     try {
83651       delete arg1;
83652     } catch (std::out_of_range& e) {
83653       {
83654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83655       };
83656     } catch (std::exception& e) {
83657       {
83658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83659       };
83660     } catch (Dali::DaliException e) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83663       };
83664     } catch (...) {
83665       {
83666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83667       };
83668     }
83669   }
83670
83671 }
83672
83673
83674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83675   void * jresult ;
83676   Dali::BaseHandle arg1 ;
83677   Dali::BaseHandle *argp1 ;
83678   Dali::Toolkit::ProgressBar result;
83679
83680   argp1 = (Dali::BaseHandle *)jarg1;
83681   if (!argp1) {
83682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83683     return 0;
83684   }
83685   arg1 = *argp1;
83686   {
83687     try {
83688       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83689     } catch (std::out_of_range& e) {
83690       {
83691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83692       };
83693     } catch (std::exception& e) {
83694       {
83695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83696       };
83697     } catch (Dali::DaliException e) {
83698       {
83699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83700       };
83701     } catch (...) {
83702       {
83703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83704       };
83705     }
83706   }
83707
83708   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83709   return jresult;
83710 }
83711
83712
83713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83714   void * jresult ;
83715   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83716   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83717
83718   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83719   {
83720     try {
83721       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83729       };
83730     } catch (Dali::DaliException e) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83733       };
83734     } catch (...) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83737       };
83738     }
83739   }
83740
83741   jresult = (void *)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83747   void * jresult ;
83748   Dali::Toolkit::GaussianBlurView *result = 0 ;
83749
83750   {
83751     try {
83752       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83753     } catch (std::out_of_range& e) {
83754       {
83755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83756       };
83757     } catch (std::exception& e) {
83758       {
83759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83760       };
83761     } catch (Dali::DaliException e) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83764       };
83765     } catch (...) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83768       };
83769     }
83770   }
83771
83772   jresult = (void *)result;
83773   return jresult;
83774 }
83775
83776
83777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83778   void * jresult ;
83779   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83780   Dali::Toolkit::GaussianBlurView *result = 0 ;
83781
83782   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83783   if (!arg1) {
83784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83785     return 0;
83786   }
83787   {
83788     try {
83789       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83790     } catch (std::out_of_range& e) {
83791       {
83792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83793       };
83794     } catch (std::exception& e) {
83795       {
83796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83797       };
83798     } catch (Dali::DaliException e) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83801       };
83802     } catch (...) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83805       };
83806     }
83807   }
83808
83809   jresult = (void *)result;
83810   return jresult;
83811 }
83812
83813
83814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83815   void * jresult ;
83816   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83817   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83818   Dali::Toolkit::GaussianBlurView *result = 0 ;
83819
83820   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83821   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83822   if (!arg2) {
83823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83824     return 0;
83825   }
83826   {
83827     try {
83828       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83829     } catch (std::out_of_range& e) {
83830       {
83831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (std::exception& e) {
83834       {
83835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (Dali::DaliException e) {
83838       {
83839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83844       };
83845     }
83846   }
83847
83848   jresult = (void *)result;
83849   return jresult;
83850 }
83851
83852
83853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83854   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83855
83856   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83857   {
83858     try {
83859       delete arg1;
83860     } catch (std::out_of_range& e) {
83861       {
83862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83863       };
83864     } catch (std::exception& e) {
83865       {
83866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83867       };
83868     } catch (Dali::DaliException e) {
83869       {
83870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83871       };
83872     } catch (...) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83875       };
83876     }
83877   }
83878
83879 }
83880
83881
83882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83883   void * jresult ;
83884   Dali::BaseHandle arg1 ;
83885   Dali::BaseHandle *argp1 ;
83886   Dali::Toolkit::GaussianBlurView result;
83887
83888   argp1 = (Dali::BaseHandle *)jarg1;
83889   if (!argp1) {
83890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83891     return 0;
83892   }
83893   arg1 = *argp1;
83894   {
83895     try {
83896       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83897     } catch (std::out_of_range& e) {
83898       {
83899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83900       };
83901     } catch (std::exception& e) {
83902       {
83903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (Dali::DaliException e) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83908       };
83909     } catch (...) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83912       };
83913     }
83914   }
83915
83916   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83917   return jresult;
83918 }
83919
83920
83921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83922   void * jresult ;
83923   Dali::Toolkit::GaussianBlurView result;
83924
83925   {
83926     try {
83927       result = Dali::Toolkit::GaussianBlurView::New();
83928     } catch (std::out_of_range& e) {
83929       {
83930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83931       };
83932     } catch (std::exception& e) {
83933       {
83934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83935       };
83936     } catch (Dali::DaliException e) {
83937       {
83938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83939       };
83940     } catch (...) {
83941       {
83942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83943       };
83944     }
83945   }
83946
83947   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83948   return jresult;
83949 }
83950
83951
83952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83953   void * jresult ;
83954   unsigned int arg1 ;
83955   float arg2 ;
83956   Dali::Pixel::Format arg3 ;
83957   float arg4 ;
83958   float arg5 ;
83959   bool arg6 ;
83960   Dali::Toolkit::GaussianBlurView result;
83961
83962   arg1 = (unsigned int)jarg1;
83963   arg2 = (float)jarg2;
83964   arg3 = (Dali::Pixel::Format)jarg3;
83965   arg4 = (float)jarg4;
83966   arg5 = (float)jarg5;
83967   arg6 = jarg6 ? true : false;
83968   {
83969     try {
83970       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (Dali::DaliException e) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83982       };
83983     } catch (...) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83986       };
83987     }
83988   }
83989
83990   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83991   return jresult;
83992 }
83993
83994
83995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83996   void * jresult ;
83997   unsigned int arg1 ;
83998   float arg2 ;
83999   Dali::Pixel::Format arg3 ;
84000   float arg4 ;
84001   float arg5 ;
84002   Dali::Toolkit::GaussianBlurView result;
84003
84004   arg1 = (unsigned int)jarg1;
84005   arg2 = (float)jarg2;
84006   arg3 = (Dali::Pixel::Format)jarg3;
84007   arg4 = (float)jarg4;
84008   arg5 = (float)jarg5;
84009   {
84010     try {
84011       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84012     } catch (std::out_of_range& e) {
84013       {
84014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84015       };
84016     } catch (std::exception& e) {
84017       {
84018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84019       };
84020     } catch (Dali::DaliException e) {
84021       {
84022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84023       };
84024     } catch (...) {
84025       {
84026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84027       };
84028     }
84029   }
84030
84031   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84032   return jresult;
84033 }
84034
84035
84036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84037   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84038   Dali::Actor arg2 ;
84039   Dali::Actor *argp2 ;
84040
84041   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84042   argp2 = (Dali::Actor *)jarg2;
84043   if (!argp2) {
84044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84045     return ;
84046   }
84047   arg2 = *argp2;
84048   {
84049     try {
84050       (arg1)->Add(arg2);
84051     } catch (std::out_of_range& e) {
84052       {
84053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84054       };
84055     } catch (std::exception& e) {
84056       {
84057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (Dali::DaliException e) {
84060       {
84061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069
84070 }
84071
84072
84073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84074   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84075   Dali::Actor arg2 ;
84076   Dali::Actor *argp2 ;
84077
84078   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84079   argp2 = (Dali::Actor *)jarg2;
84080   if (!argp2) {
84081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84082     return ;
84083   }
84084   arg2 = *argp2;
84085   {
84086     try {
84087       (arg1)->Remove(arg2);
84088     } catch (std::out_of_range& e) {
84089       {
84090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84091       };
84092     } catch (std::exception& e) {
84093       {
84094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84095       };
84096     } catch (Dali::DaliException e) {
84097       {
84098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84099       };
84100     } catch (...) {
84101       {
84102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84103       };
84104     }
84105   }
84106
84107 }
84108
84109
84110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84111   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84112
84113   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84114   {
84115     try {
84116       (arg1)->Activate();
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84132       };
84133     }
84134   }
84135
84136 }
84137
84138
84139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84140   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84141
84142   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84143   {
84144     try {
84145       (arg1)->ActivateOnce();
84146     } catch (std::out_of_range& e) {
84147       {
84148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84149       };
84150     } catch (std::exception& e) {
84151       {
84152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84153       };
84154     } catch (Dali::DaliException e) {
84155       {
84156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84157       };
84158     } catch (...) {
84159       {
84160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84161       };
84162     }
84163   }
84164
84165 }
84166
84167
84168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84169   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84170
84171   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84172   {
84173     try {
84174       (arg1)->Deactivate();
84175     } catch (std::out_of_range& e) {
84176       {
84177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84178       };
84179     } catch (std::exception& e) {
84180       {
84181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84182       };
84183     } catch (Dali::DaliException e) {
84184       {
84185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84186       };
84187     } catch (...) {
84188       {
84189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84190       };
84191     }
84192   }
84193
84194 }
84195
84196
84197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84198   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84199   Dali::Texture arg2 ;
84200   Dali::FrameBuffer arg3 ;
84201   Dali::Texture *argp2 ;
84202   Dali::FrameBuffer *argp3 ;
84203
84204   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84205   argp2 = (Dali::Texture *)jarg2;
84206   if (!argp2) {
84207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84208     return ;
84209   }
84210   arg2 = *argp2;
84211   argp3 = (Dali::FrameBuffer *)jarg3;
84212   if (!argp3) {
84213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84214     return ;
84215   }
84216   arg3 = *argp3;
84217   {
84218     try {
84219       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84220     } catch (std::out_of_range& e) {
84221       {
84222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84223       };
84224     } catch (std::exception& e) {
84225       {
84226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84227       };
84228     } catch (Dali::DaliException e) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84231       };
84232     } catch (...) {
84233       {
84234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84235       };
84236     }
84237   }
84238
84239 }
84240
84241
84242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84243   int jresult ;
84244   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84245   Dali::Property::Index result;
84246
84247   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84248   {
84249     try {
84250       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84251     } catch (std::out_of_range& e) {
84252       {
84253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84254       };
84255     } catch (std::exception& e) {
84256       {
84257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84258       };
84259     } catch (Dali::DaliException e) {
84260       {
84261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84262       };
84263     } catch (...) {
84264       {
84265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84266       };
84267     }
84268   }
84269
84270   jresult = result;
84271   return jresult;
84272 }
84273
84274
84275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84276   void * jresult ;
84277   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84278   Dali::FrameBuffer result;
84279
84280   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84281   {
84282     try {
84283       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84284     } catch (std::out_of_range& e) {
84285       {
84286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84287       };
84288     } catch (std::exception& e) {
84289       {
84290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84291       };
84292     } catch (Dali::DaliException e) {
84293       {
84294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84295       };
84296     } catch (...) {
84297       {
84298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84299       };
84300     }
84301   }
84302
84303   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84304   return jresult;
84305 }
84306
84307
84308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84309   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84310   Dali::Vector4 *arg2 = 0 ;
84311
84312   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84313   arg2 = (Dali::Vector4 *)jarg2;
84314   if (!arg2) {
84315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84316     return ;
84317   }
84318   {
84319     try {
84320       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84321     } catch (std::out_of_range& e) {
84322       {
84323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84324       };
84325     } catch (std::exception& e) {
84326       {
84327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84328       };
84329     } catch (Dali::DaliException e) {
84330       {
84331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84332       };
84333     } catch (...) {
84334       {
84335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84336       };
84337     }
84338   }
84339
84340 }
84341
84342
84343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84344   void * jresult ;
84345   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84346   Dali::Vector4 result;
84347
84348   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84349   {
84350     try {
84351       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84359       };
84360     } catch (Dali::DaliException e) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84367       };
84368     }
84369   }
84370
84371   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84372   return jresult;
84373 }
84374
84375
84376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84377   void * jresult ;
84378   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84379   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84380
84381   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84382   {
84383     try {
84384       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84385     } catch (std::out_of_range& e) {
84386       {
84387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (std::exception& e) {
84390       {
84391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84392       };
84393     } catch (Dali::DaliException e) {
84394       {
84395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84396       };
84397     } catch (...) {
84398       {
84399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84400       };
84401     }
84402   }
84403
84404   jresult = (void *)result;
84405   return jresult;
84406 }
84407
84408
84409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84410   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84411
84412   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84413   {
84414     try {
84415       delete arg1;
84416     } catch (std::out_of_range& e) {
84417       {
84418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84419       };
84420     } catch (std::exception& e) {
84421       {
84422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84423       };
84424     } catch (Dali::DaliException e) {
84425       {
84426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84427       };
84428     } catch (...) {
84429       {
84430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84431       };
84432     }
84433   }
84434
84435 }
84436
84437
84438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84439   unsigned int jresult ;
84440   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84441   unsigned int result;
84442
84443   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84444   {
84445     try {
84446       result = (unsigned int)(arg1)->GetNumberOfPages();
84447     } catch (std::out_of_range& e) {
84448       {
84449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84450       };
84451     } catch (std::exception& e) {
84452       {
84453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84454       };
84455     } catch (Dali::DaliException e) {
84456       {
84457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84458       };
84459     } catch (...) {
84460       {
84461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84462       };
84463     }
84464   }
84465
84466   jresult = result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84472   void * jresult ;
84473   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84474   unsigned int arg2 ;
84475   Dali::Texture result;
84476
84477   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84478   arg2 = (unsigned int)jarg2;
84479   {
84480     try {
84481       result = (arg1)->NewPage(arg2);
84482     } catch (std::out_of_range& e) {
84483       {
84484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84485       };
84486     } catch (std::exception& e) {
84487       {
84488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84489       };
84490     } catch (Dali::DaliException e) {
84491       {
84492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84493       };
84494     } catch (...) {
84495       {
84496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84497       };
84498     }
84499   }
84500
84501   jresult = new Dali::Texture((const Dali::Texture &)result);
84502   return jresult;
84503 }
84504
84505
84506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84507   int jresult ;
84508   int result;
84509
84510   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84511   jresult = (int)result;
84512   return jresult;
84513 }
84514
84515
84516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84517   int jresult ;
84518   int result;
84519
84520   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84521   jresult = (int)result;
84522   return jresult;
84523 }
84524
84525
84526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84527   int jresult ;
84528   int result;
84529
84530   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84531   jresult = (int)result;
84532   return jresult;
84533 }
84534
84535
84536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84537   void * jresult ;
84538   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84539
84540   {
84541     try {
84542       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (Dali::DaliException e) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561
84562   jresult = (void *)result;
84563   return jresult;
84564 }
84565
84566
84567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84568   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84569
84570   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84571   {
84572     try {
84573       delete arg1;
84574     } catch (std::out_of_range& e) {
84575       {
84576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84577       };
84578     } catch (std::exception& e) {
84579       {
84580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84581       };
84582     } catch (Dali::DaliException e) {
84583       {
84584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84585       };
84586     } catch (...) {
84587       {
84588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84589       };
84590     }
84591   }
84592
84593 }
84594
84595
84596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84597   void * jresult ;
84598   Dali::Toolkit::PageTurnView *result = 0 ;
84599
84600   {
84601     try {
84602       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84603     } catch (std::out_of_range& e) {
84604       {
84605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84606       };
84607     } catch (std::exception& e) {
84608       {
84609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84610       };
84611     } catch (Dali::DaliException e) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84614       };
84615     } catch (...) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84618       };
84619     }
84620   }
84621
84622   jresult = (void *)result;
84623   return jresult;
84624 }
84625
84626
84627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84628   void * jresult ;
84629   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84630   Dali::Toolkit::PageTurnView *result = 0 ;
84631
84632   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84633   if (!arg1) {
84634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84635     return 0;
84636   }
84637   {
84638     try {
84639       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84640     } catch (std::out_of_range& e) {
84641       {
84642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84643       };
84644     } catch (std::exception& e) {
84645       {
84646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84647       };
84648     } catch (Dali::DaliException e) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84651       };
84652     } catch (...) {
84653       {
84654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84655       };
84656     }
84657   }
84658
84659   jresult = (void *)result;
84660   return jresult;
84661 }
84662
84663
84664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84665   void * jresult ;
84666   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84667   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84668   Dali::Toolkit::PageTurnView *result = 0 ;
84669
84670   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84671   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84672   if (!arg2) {
84673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84674     return 0;
84675   }
84676   {
84677     try {
84678       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84679     } catch (std::out_of_range& e) {
84680       {
84681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (std::exception& e) {
84684       {
84685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84686       };
84687     } catch (Dali::DaliException e) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84690       };
84691     } catch (...) {
84692       {
84693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84694       };
84695     }
84696   }
84697
84698   jresult = (void *)result;
84699   return jresult;
84700 }
84701
84702
84703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84704   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84705
84706   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84707   {
84708     try {
84709       delete arg1;
84710     } catch (std::out_of_range& e) {
84711       {
84712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84713       };
84714     } catch (std::exception& e) {
84715       {
84716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84717       };
84718     } catch (Dali::DaliException e) {
84719       {
84720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84721       };
84722     } catch (...) {
84723       {
84724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84725       };
84726     }
84727   }
84728
84729 }
84730
84731
84732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84733   void * jresult ;
84734   Dali::BaseHandle arg1 ;
84735   Dali::BaseHandle *argp1 ;
84736   Dali::Toolkit::PageTurnView result;
84737
84738   argp1 = (Dali::BaseHandle *)jarg1;
84739   if (!argp1) {
84740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84741     return 0;
84742   }
84743   arg1 = *argp1;
84744   {
84745     try {
84746       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84747     } catch (std::out_of_range& e) {
84748       {
84749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84750       };
84751     } catch (std::exception& e) {
84752       {
84753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84754       };
84755     } catch (Dali::DaliException e) {
84756       {
84757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84762       };
84763     }
84764   }
84765
84766   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84767   return jresult;
84768 }
84769
84770
84771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84772   void * jresult ;
84773   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84774   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84775
84776   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84777   {
84778     try {
84779       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (Dali::DaliException e) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84795       };
84796     }
84797   }
84798
84799   jresult = (void *)result;
84800   return jresult;
84801 }
84802
84803
84804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84805   void * jresult ;
84806   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84807   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84808
84809   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84810   {
84811     try {
84812       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (Dali::DaliException e) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84824       };
84825     } catch (...) {
84826       {
84827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84828       };
84829     }
84830   }
84831
84832   jresult = (void *)result;
84833   return jresult;
84834 }
84835
84836
84837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84838   void * jresult ;
84839   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84840   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84841
84842   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84843   {
84844     try {
84845       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84846     } catch (std::out_of_range& e) {
84847       {
84848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84849       };
84850     } catch (std::exception& e) {
84851       {
84852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84853       };
84854     } catch (Dali::DaliException e) {
84855       {
84856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84857       };
84858     } catch (...) {
84859       {
84860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84861       };
84862     }
84863   }
84864
84865   jresult = (void *)result;
84866   return jresult;
84867 }
84868
84869
84870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84871   void * jresult ;
84872   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84873   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84874
84875   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84876   {
84877     try {
84878       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84879     } catch (std::out_of_range& e) {
84880       {
84881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84882       };
84883     } catch (std::exception& e) {
84884       {
84885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (Dali::DaliException e) {
84888       {
84889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897
84898   jresult = (void *)result;
84899   return jresult;
84900 }
84901
84902
84903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84904   void * jresult ;
84905   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84906
84907   {
84908     try {
84909       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84910     } catch (std::out_of_range& e) {
84911       {
84912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84913       };
84914     } catch (std::exception& e) {
84915       {
84916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (Dali::DaliException e) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84921       };
84922     } catch (...) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84925       };
84926     }
84927   }
84928
84929   jresult = (void *)result;
84930   return jresult;
84931 }
84932
84933
84934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84935   void * jresult ;
84936   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84937   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84938
84939   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84940   if (!arg1) {
84941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84942     return 0;
84943   }
84944   {
84945     try {
84946       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (Dali::DaliException e) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965
84966   jresult = (void *)result;
84967   return jresult;
84968 }
84969
84970
84971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84972   void * jresult ;
84973   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84974   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84975   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84976
84977   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84978   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84979   if (!arg2) {
84980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84981     return 0;
84982   }
84983   {
84984     try {
84985       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84986     } catch (std::out_of_range& e) {
84987       {
84988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (std::exception& e) {
84991       {
84992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84993       };
84994     } catch (Dali::DaliException e) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84997       };
84998     } catch (...) {
84999       {
85000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85001       };
85002     }
85003   }
85004
85005   jresult = (void *)result;
85006   return jresult;
85007 }
85008
85009
85010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85011   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85012
85013   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85014   {
85015     try {
85016       delete arg1;
85017     } catch (std::out_of_range& e) {
85018       {
85019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85020       };
85021     } catch (std::exception& e) {
85022       {
85023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85024       };
85025     } catch (Dali::DaliException e) {
85026       {
85027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85028       };
85029     } catch (...) {
85030       {
85031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85032       };
85033     }
85034   }
85035
85036 }
85037
85038
85039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85040   void * jresult ;
85041   Dali::Toolkit::PageFactory *arg1 = 0 ;
85042   Dali::Vector2 *arg2 = 0 ;
85043   Dali::Toolkit::PageTurnLandscapeView result;
85044
85045   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85046   if (!arg1) {
85047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85048     return 0;
85049   }
85050   arg2 = (Dali::Vector2 *)jarg2;
85051   if (!arg2) {
85052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85053     return 0;
85054   }
85055   {
85056     try {
85057       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
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 = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85078   return jresult;
85079 }
85080
85081
85082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85083   void * jresult ;
85084   Dali::BaseHandle arg1 ;
85085   Dali::BaseHandle *argp1 ;
85086   Dali::Toolkit::PageTurnLandscapeView result;
85087
85088   argp1 = (Dali::BaseHandle *)jarg1;
85089   if (!argp1) {
85090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85091     return 0;
85092   }
85093   arg1 = *argp1;
85094   {
85095     try {
85096       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85097     } catch (std::out_of_range& e) {
85098       {
85099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85100       };
85101     } catch (std::exception& e) {
85102       {
85103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85104       };
85105     } catch (Dali::DaliException e) {
85106       {
85107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85108       };
85109     } catch (...) {
85110       {
85111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85112       };
85113     }
85114   }
85115
85116   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85117   return jresult;
85118 }
85119
85120
85121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85122   void * jresult ;
85123   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85124
85125   {
85126     try {
85127       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85128     } catch (std::out_of_range& e) {
85129       {
85130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85131       };
85132     } catch (std::exception& e) {
85133       {
85134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85135       };
85136     } catch (Dali::DaliException e) {
85137       {
85138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85139       };
85140     } catch (...) {
85141       {
85142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85143       };
85144     }
85145   }
85146
85147   jresult = (void *)result;
85148   return jresult;
85149 }
85150
85151
85152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85153   void * jresult ;
85154   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85155   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85156
85157   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85158   if (!arg1) {
85159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85160     return 0;
85161   }
85162   {
85163     try {
85164       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85165     } catch (std::out_of_range& e) {
85166       {
85167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85168       };
85169     } catch (std::exception& e) {
85170       {
85171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85172       };
85173     } catch (Dali::DaliException e) {
85174       {
85175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85176       };
85177     } catch (...) {
85178       {
85179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85180       };
85181     }
85182   }
85183
85184   jresult = (void *)result;
85185   return jresult;
85186 }
85187
85188
85189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85190   void * jresult ;
85191   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85192   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85193   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85194
85195   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85196   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85197   if (!arg2) {
85198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85199     return 0;
85200   }
85201   {
85202     try {
85203       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85204     } catch (std::out_of_range& e) {
85205       {
85206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85207       };
85208     } catch (std::exception& e) {
85209       {
85210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85211       };
85212     } catch (Dali::DaliException e) {
85213       {
85214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85215       };
85216     } catch (...) {
85217       {
85218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85219       };
85220     }
85221   }
85222
85223   jresult = (void *)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85229   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85230
85231   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85232   {
85233     try {
85234       delete arg1;
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85242       };
85243     } catch (Dali::DaliException e) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85246       };
85247     } catch (...) {
85248       {
85249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85250       };
85251     }
85252   }
85253
85254 }
85255
85256
85257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85258   void * jresult ;
85259   Dali::Toolkit::PageFactory *arg1 = 0 ;
85260   Dali::Vector2 *arg2 = 0 ;
85261   Dali::Toolkit::PageTurnPortraitView result;
85262
85263   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85264   if (!arg1) {
85265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85266     return 0;
85267   }
85268   arg2 = (Dali::Vector2 *)jarg2;
85269   if (!arg2) {
85270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85271     return 0;
85272   }
85273   {
85274     try {
85275       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85276     } catch (std::out_of_range& e) {
85277       {
85278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85279       };
85280     } catch (std::exception& e) {
85281       {
85282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85283       };
85284     } catch (Dali::DaliException e) {
85285       {
85286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85287       };
85288     } catch (...) {
85289       {
85290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85291       };
85292     }
85293   }
85294
85295   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85296   return jresult;
85297 }
85298
85299
85300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85301   void * jresult ;
85302   Dali::BaseHandle arg1 ;
85303   Dali::BaseHandle *argp1 ;
85304   Dali::Toolkit::PageTurnPortraitView result;
85305
85306   argp1 = (Dali::BaseHandle *)jarg1;
85307   if (!argp1) {
85308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85309     return 0;
85310   }
85311   arg1 = *argp1;
85312   {
85313     try {
85314       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85315     } catch (std::out_of_range& e) {
85316       {
85317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85318       };
85319     } catch (std::exception& e) {
85320       {
85321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (Dali::DaliException e) {
85324       {
85325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85326       };
85327     } catch (...) {
85328       {
85329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85330       };
85331     }
85332   }
85333
85334   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85335   return jresult;
85336 }
85337
85338
85339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85340   int jresult ;
85341   int result;
85342
85343   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85344   jresult = (int)result;
85345   return jresult;
85346 }
85347
85348
85349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85350   int jresult ;
85351   int result;
85352
85353   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85354   jresult = (int)result;
85355   return jresult;
85356 }
85357
85358
85359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85360   int jresult ;
85361   int result;
85362
85363   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85364   jresult = (int)result;
85365   return jresult;
85366 }
85367
85368
85369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85370   void * jresult ;
85371   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85372
85373   {
85374     try {
85375       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85376     } catch (std::out_of_range& e) {
85377       {
85378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (std::exception& e) {
85381       {
85382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85383       };
85384     } catch (Dali::DaliException e) {
85385       {
85386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85387       };
85388     } catch (...) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85391       };
85392     }
85393   }
85394
85395   jresult = (void *)result;
85396   return jresult;
85397 }
85398
85399
85400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85401   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85402
85403   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85404   {
85405     try {
85406       delete arg1;
85407     } catch (std::out_of_range& e) {
85408       {
85409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85410       };
85411     } catch (std::exception& e) {
85412       {
85413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85414       };
85415     } catch (Dali::DaliException e) {
85416       {
85417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85418       };
85419     } catch (...) {
85420       {
85421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85422       };
85423     }
85424   }
85425
85426 }
85427
85428
85429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85430   void * jresult ;
85431   Dali::Toolkit::ToggleButton *result = 0 ;
85432
85433   {
85434     try {
85435       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85436     } catch (std::out_of_range& e) {
85437       {
85438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85439       };
85440     } catch (std::exception& e) {
85441       {
85442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85443       };
85444     } catch (Dali::DaliException e) {
85445       {
85446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85447       };
85448     } catch (...) {
85449       {
85450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85451       };
85452     }
85453   }
85454
85455   jresult = (void *)result;
85456   return jresult;
85457 }
85458
85459
85460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85461   void * jresult ;
85462   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85463   Dali::Toolkit::ToggleButton *result = 0 ;
85464
85465   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85466   if (!arg1) {
85467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85468     return 0;
85469   }
85470   {
85471     try {
85472       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85473     } catch (std::out_of_range& e) {
85474       {
85475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85476       };
85477     } catch (std::exception& e) {
85478       {
85479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85480       };
85481     } catch (Dali::DaliException e) {
85482       {
85483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85484       };
85485     } catch (...) {
85486       {
85487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85488       };
85489     }
85490   }
85491
85492   jresult = (void *)result;
85493   return jresult;
85494 }
85495
85496
85497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85498   void * jresult ;
85499   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85500   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85501   Dali::Toolkit::ToggleButton *result = 0 ;
85502
85503   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85504   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85505   if (!arg2) {
85506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85507     return 0;
85508   }
85509   {
85510     try {
85511       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85519       };
85520     } catch (Dali::DaliException e) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85523       };
85524     } catch (...) {
85525       {
85526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85527       };
85528     }
85529   }
85530
85531   jresult = (void *)result;
85532   return jresult;
85533 }
85534
85535
85536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85537   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85538
85539   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85540   {
85541     try {
85542       delete arg1;
85543     } catch (std::out_of_range& e) {
85544       {
85545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85546       };
85547     } catch (std::exception& e) {
85548       {
85549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85550       };
85551     } catch (Dali::DaliException e) {
85552       {
85553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85554       };
85555     } catch (...) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85558       };
85559     }
85560   }
85561
85562 }
85563
85564
85565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85566   void * jresult ;
85567   Dali::Toolkit::ToggleButton result;
85568
85569   {
85570     try {
85571       result = Dali::Toolkit::ToggleButton::New();
85572     } catch (std::out_of_range& e) {
85573       {
85574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85575       };
85576     } catch (std::exception& e) {
85577       {
85578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85579       };
85580     } catch (Dali::DaliException e) {
85581       {
85582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85583       };
85584     } catch (...) {
85585       {
85586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85587       };
85588     }
85589   }
85590
85591   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85592   return jresult;
85593 }
85594
85595
85596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85597   void * jresult ;
85598   Dali::BaseHandle arg1 ;
85599   Dali::BaseHandle *argp1 ;
85600   Dali::Toolkit::ToggleButton result;
85601
85602   argp1 = (Dali::BaseHandle *)jarg1;
85603   if (!argp1) {
85604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85605     return 0;
85606   }
85607   arg1 = *argp1;
85608   {
85609     try {
85610       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85611     } catch (std::out_of_range& e) {
85612       {
85613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85614       };
85615     } catch (std::exception& e) {
85616       {
85617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85618       };
85619     } catch (Dali::DaliException e) {
85620       {
85621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85622       };
85623     } catch (...) {
85624       {
85625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85626       };
85627     }
85628   }
85629
85630   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85631   return jresult;
85632 }
85633
85634
85635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85636   void * jresult ;
85637   Dali::Toolkit::Visual::Base *result = 0 ;
85638
85639   {
85640     try {
85641       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85642     } catch (std::out_of_range& e) {
85643       {
85644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85645       };
85646     } catch (std::exception& e) {
85647       {
85648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85649       };
85650     } catch (Dali::DaliException e) {
85651       {
85652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85653       };
85654     } catch (...) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85657       };
85658     }
85659   }
85660
85661   jresult = (void *)result;
85662   return jresult;
85663 }
85664
85665
85666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85667   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85668
85669   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85670   {
85671     try {
85672       delete arg1;
85673     } catch (std::out_of_range& e) {
85674       {
85675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85676       };
85677     } catch (std::exception& e) {
85678       {
85679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85680       };
85681     } catch (Dali::DaliException e) {
85682       {
85683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85684       };
85685     } catch (...) {
85686       {
85687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85688       };
85689     }
85690   }
85691
85692 }
85693
85694
85695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85696   void * jresult ;
85697   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85698   Dali::Toolkit::Visual::Base *result = 0 ;
85699
85700   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85701   if (!arg1) {
85702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85703     return 0;
85704   }
85705   {
85706     try {
85707       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85708     } catch (std::out_of_range& e) {
85709       {
85710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85711       };
85712     } catch (std::exception& e) {
85713       {
85714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85715       };
85716     } catch (Dali::DaliException e) {
85717       {
85718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85719       };
85720     } catch (...) {
85721       {
85722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85723       };
85724     }
85725   }
85726
85727   jresult = (void *)result;
85728   return jresult;
85729 }
85730
85731
85732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85733   void * jresult ;
85734   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85735   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85736   Dali::Toolkit::Visual::Base *result = 0 ;
85737
85738   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85739   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85740   if (!arg2) {
85741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85742     return 0;
85743   }
85744   {
85745     try {
85746       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85747     } catch (std::out_of_range& e) {
85748       {
85749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85750       };
85751     } catch (std::exception& e) {
85752       {
85753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85754       };
85755     } catch (Dali::DaliException e) {
85756       {
85757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85758       };
85759     } catch (...) {
85760       {
85761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85762       };
85763     }
85764   }
85765
85766   jresult = (void *)result;
85767   return jresult;
85768 }
85769
85770
85771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85772   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85773   std::string *arg2 = 0 ;
85774
85775   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85776   if (!jarg2) {
85777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85778     return ;
85779   }
85780   std::string arg2_str(jarg2);
85781   arg2 = &arg2_str;
85782   {
85783     try {
85784       (arg1)->SetName((std::string const &)*arg2);
85785     } catch (std::out_of_range& e) {
85786       {
85787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85788       };
85789     } catch (std::exception& e) {
85790       {
85791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85792       };
85793     } catch (Dali::DaliException e) {
85794       {
85795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85796       };
85797     } catch (...) {
85798       {
85799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85800       };
85801     }
85802   }
85803
85804
85805   //argout typemap for const std::string&
85806
85807 }
85808
85809
85810 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85811   char * jresult ;
85812   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85813   std::string *result = 0 ;
85814
85815   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85816   {
85817     try {
85818       result = (std::string *) &(arg1)->GetName();
85819     } catch (std::out_of_range& e) {
85820       {
85821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85822       };
85823     } catch (std::exception& e) {
85824       {
85825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85826       };
85827     } catch (Dali::DaliException e) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85830       };
85831     } catch (...) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85834       };
85835     }
85836   }
85837
85838   jresult = SWIG_csharp_string_callback(result->c_str());
85839   return jresult;
85840 }
85841
85842
85843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85844   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85845   Dali::Property::Map *arg2 = 0 ;
85846   Dali::Size arg3 ;
85847   Dali::Size *argp3 ;
85848
85849   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85850   arg2 = (Dali::Property::Map *)jarg2;
85851   if (!arg2) {
85852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85853     return ;
85854   }
85855   argp3 = (Dali::Size *)jarg3;
85856   if (!argp3) {
85857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85858     return ;
85859   }
85860   arg3 = *argp3;
85861   {
85862     try {
85863       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85864     } catch (std::out_of_range& e) {
85865       {
85866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85867       };
85868     } catch (std::exception& e) {
85869       {
85870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85871       };
85872     } catch (Dali::DaliException e) {
85873       {
85874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85875       };
85876     } catch (...) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85879       };
85880     }
85881   }
85882
85883 }
85884
85885
85886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85887   float jresult ;
85888   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85889   float arg2 ;
85890   float result;
85891
85892   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85893   arg2 = (float)jarg2;
85894   {
85895     try {
85896       result = (float)(arg1)->GetHeightForWidth(arg2);
85897     } catch (std::out_of_range& e) {
85898       {
85899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85900       };
85901     } catch (std::exception& e) {
85902       {
85903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (Dali::DaliException e) {
85906       {
85907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85908       };
85909     } catch (...) {
85910       {
85911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85912       };
85913     }
85914   }
85915
85916   jresult = result;
85917   return jresult;
85918 }
85919
85920
85921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85922   float jresult ;
85923   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85924   float arg2 ;
85925   float result;
85926
85927   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85928   arg2 = (float)jarg2;
85929   {
85930     try {
85931       result = (float)(arg1)->GetWidthForHeight(arg2);
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (Dali::DaliException e) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85943       };
85944     } catch (...) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85947       };
85948     }
85949   }
85950
85951   jresult = result;
85952   return jresult;
85953 }
85954
85955
85956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85957   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85958   Dali::Vector2 *arg2 = 0 ;
85959
85960   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85961   arg2 = (Dali::Vector2 *)jarg2;
85962   if (!arg2) {
85963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85964     return ;
85965   }
85966   {
85967     try {
85968       (arg1)->GetNaturalSize(*arg2);
85969     } catch (std::out_of_range& e) {
85970       {
85971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85972       };
85973     } catch (std::exception& e) {
85974       {
85975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85976       };
85977     } catch (Dali::DaliException e) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85980       };
85981     } catch (...) {
85982       {
85983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85984       };
85985     }
85986   }
85987
85988 }
85989
85990
85991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85992   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85993   float arg2 ;
85994
85995   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85996   arg2 = (int)jarg2;
85997   {
85998     try {
85999       (arg1)->SetDepthIndex(arg2);
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86007       };
86008     } catch (Dali::DaliException e) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86011       };
86012     } catch (...) {
86013       {
86014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86015       };
86016     }
86017   }
86018
86019 }
86020
86021
86022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86023   int jresult ;
86024   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86025   int result;
86026
86027   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86028   {
86029     try {
86030       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
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 = result;
86051   return jresult;
86052 }
86053
86054
86055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86056   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86057   Dali::Property::Map *arg2 = 0 ;
86058
86059   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86060   arg2 = (Dali::Property::Map *)jarg2;
86061   if (!arg2) {
86062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86063     return ;
86064   }
86065   {
86066     try {
86067       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86068     } catch (std::out_of_range& e) {
86069       {
86070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86071       };
86072     } catch (std::exception& e) {
86073       {
86074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86075       };
86076     } catch (Dali::DaliException e) {
86077       {
86078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86079       };
86080     } catch (...) {
86081       {
86082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86083       };
86084     }
86085   }
86086
86087 }
86088
86089
86090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86091   void * jresult ;
86092   Dali::Toolkit::VisualFactory result;
86093
86094   {
86095     try {
86096       result = Dali::Toolkit::VisualFactory::Get();
86097     } catch (std::out_of_range& e) {
86098       {
86099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86100       };
86101     } catch (std::exception& e) {
86102       {
86103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (Dali::DaliException e) {
86106       {
86107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86108       };
86109     } catch (...) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86112       };
86113     }
86114   }
86115
86116   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86117   return jresult;
86118 }
86119
86120
86121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86122   void * jresult ;
86123   Dali::Toolkit::VisualFactory *result = 0 ;
86124
86125   {
86126     try {
86127       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86128     } catch (std::out_of_range& e) {
86129       {
86130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86131       };
86132     } catch (std::exception& e) {
86133       {
86134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (Dali::DaliException e) {
86137       {
86138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86139       };
86140     } catch (...) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86143       };
86144     }
86145   }
86146
86147   jresult = (void *)result;
86148   return jresult;
86149 }
86150
86151
86152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86153   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86154
86155   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86156   {
86157     try {
86158       delete arg1;
86159     } catch (std::out_of_range& e) {
86160       {
86161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86162       };
86163     } catch (std::exception& e) {
86164       {
86165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86166       };
86167     } catch (Dali::DaliException e) {
86168       {
86169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86170       };
86171     } catch (...) {
86172       {
86173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86174       };
86175     }
86176   }
86177
86178 }
86179
86180
86181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86182   void * jresult ;
86183   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86184   Dali::Toolkit::VisualFactory *result = 0 ;
86185
86186   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86187   if (!arg1) {
86188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86189     return 0;
86190   }
86191   {
86192     try {
86193       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86194     } catch (std::out_of_range& e) {
86195       {
86196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86197       };
86198     } catch (std::exception& e) {
86199       {
86200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (Dali::DaliException e) {
86203       {
86204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86205       };
86206     } catch (...) {
86207       {
86208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86209       };
86210     }
86211   }
86212
86213   jresult = (void *)result;
86214   return jresult;
86215 }
86216
86217
86218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86219   void * jresult ;
86220   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86221   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86222   Dali::Toolkit::VisualFactory *result = 0 ;
86223
86224   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86225   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86226   if (!arg2) {
86227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86228     return 0;
86229   }
86230   {
86231     try {
86232       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86233     } catch (std::out_of_range& e) {
86234       {
86235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (std::exception& e) {
86238       {
86239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (Dali::DaliException e) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86244       };
86245     } catch (...) {
86246       {
86247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86248       };
86249     }
86250   }
86251
86252   jresult = (void *)result;
86253   return jresult;
86254 }
86255
86256
86257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86258   void * jresult ;
86259   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86260   Dali::Property::Map *arg2 = 0 ;
86261   Dali::Toolkit::Visual::Base result;
86262
86263   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86264   arg2 = (Dali::Property::Map *)jarg2;
86265   if (!arg2) {
86266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86267     return 0;
86268   }
86269   {
86270     try {
86271       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86272     } catch (std::out_of_range& e) {
86273       {
86274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86275       };
86276     } catch (std::exception& e) {
86277       {
86278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86279       };
86280     } catch (Dali::DaliException e) {
86281       {
86282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86283       };
86284     } catch (...) {
86285       {
86286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86287       };
86288     }
86289   }
86290
86291   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86292   return jresult;
86293 }
86294
86295
86296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86297   void * jresult ;
86298   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86299   std::string *arg2 = 0 ;
86300   Dali::ImageDimensions arg3 ;
86301   Dali::ImageDimensions *argp3 ;
86302   Dali::Toolkit::Visual::Base result;
86303
86304   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86305   if (!jarg2) {
86306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86307     return 0;
86308   }
86309   std::string arg2_str(jarg2);
86310   arg2 = &arg2_str;
86311   argp3 = (Dali::ImageDimensions *)jarg3;
86312   if (!argp3) {
86313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86314     return 0;
86315   }
86316   arg3 = *argp3;
86317   {
86318     try {
86319       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86320     } catch (std::out_of_range& e) {
86321       {
86322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86323       };
86324     } catch (std::exception& e) {
86325       {
86326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86327       };
86328     } catch (Dali::DaliException e) {
86329       {
86330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86331       };
86332     } catch (...) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86335       };
86336     }
86337   }
86338
86339   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86340
86341   //argout typemap for const std::string&
86342
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86348   void * jresult ;
86349   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86350
86351   {
86352     try {
86353       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86354     } catch (std::out_of_range& e) {
86355       {
86356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (std::exception& e) {
86359       {
86360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (Dali::DaliException e) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372
86373   jresult = (void *)result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86379   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86380
86381   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86382   {
86383     try {
86384       delete arg1;
86385     } catch (std::out_of_range& e) {
86386       {
86387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (std::exception& e) {
86390       {
86391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86392       };
86393     } catch (Dali::DaliException e) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86400       };
86401     }
86402   }
86403
86404 }
86405
86406
86407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86408   void * jresult ;
86409   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86410   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86411
86412   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86413   if (!arg1) {
86414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86415     return 0;
86416   }
86417   {
86418     try {
86419       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86420     } catch (std::out_of_range& e) {
86421       {
86422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86423       };
86424     } catch (std::exception& e) {
86425       {
86426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86427       };
86428     } catch (Dali::DaliException e) {
86429       {
86430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86435       };
86436     }
86437   }
86438
86439   jresult = (void *)result;
86440   return jresult;
86441 }
86442
86443
86444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86445   void * jresult ;
86446   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86447   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86448   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86449
86450   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86451   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86452   if (!arg2) {
86453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86454     return 0;
86455   }
86456   {
86457     try {
86458       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86459     } catch (std::out_of_range& e) {
86460       {
86461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86462       };
86463     } catch (std::exception& e) {
86464       {
86465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86466       };
86467     } catch (Dali::DaliException e) {
86468       {
86469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86470       };
86471     } catch (...) {
86472       {
86473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86474       };
86475     }
86476   }
86477
86478   jresult = (void *)result;
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86484   void * jresult ;
86485   Dali::Toolkit::AsyncImageLoader result;
86486
86487   {
86488     try {
86489       result = Dali::Toolkit::AsyncImageLoader::New();
86490     } catch (std::out_of_range& e) {
86491       {
86492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86493       };
86494     } catch (std::exception& e) {
86495       {
86496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86497       };
86498     } catch (Dali::DaliException e) {
86499       {
86500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86501       };
86502     } catch (...) {
86503       {
86504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86505       };
86506     }
86507   }
86508
86509   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86510   return jresult;
86511 }
86512
86513
86514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86515   void * jresult ;
86516   Dali::BaseHandle arg1 ;
86517   Dali::BaseHandle *argp1 ;
86518   Dali::Toolkit::AsyncImageLoader result;
86519
86520   argp1 = (Dali::BaseHandle *)jarg1;
86521   if (!argp1) {
86522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86523     return 0;
86524   }
86525   arg1 = *argp1;
86526   {
86527     try {
86528       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86529     } catch (std::out_of_range& e) {
86530       {
86531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86532       };
86533     } catch (std::exception& e) {
86534       {
86535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86536       };
86537     } catch (Dali::DaliException e) {
86538       {
86539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86540       };
86541     } catch (...) {
86542       {
86543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86544       };
86545     }
86546   }
86547
86548   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86549   return jresult;
86550 }
86551
86552
86553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86554   unsigned int jresult ;
86555   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86556   std::string *arg2 = 0 ;
86557   uint32_t result;
86558
86559   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86560   if (!jarg2) {
86561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86562     return 0;
86563   }
86564   std::string arg2_str(jarg2);
86565   arg2 = &arg2_str;
86566   {
86567     try {
86568       result = (arg1)->Load((std::string const &)*arg2);
86569     } catch (std::out_of_range& e) {
86570       {
86571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86572       };
86573     } catch (std::exception& e) {
86574       {
86575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (Dali::DaliException e) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86580       };
86581     } catch (...) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86584       };
86585     }
86586   }
86587
86588   jresult = result;
86589
86590   //argout typemap for const std::string&
86591
86592   return jresult;
86593 }
86594
86595
86596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86597   unsigned int jresult ;
86598   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86599   std::string *arg2 = 0 ;
86600   Dali::ImageDimensions arg3 ;
86601   Dali::ImageDimensions *argp3 ;
86602   uint32_t result;
86603
86604   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86605   if (!jarg2) {
86606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86607     return 0;
86608   }
86609   std::string arg2_str(jarg2);
86610   arg2 = &arg2_str;
86611   argp3 = (Dali::ImageDimensions *)jarg3;
86612   if (!argp3) {
86613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86614     return 0;
86615   }
86616   arg3 = *argp3;
86617   {
86618     try {
86619       result = (arg1)->Load((std::string const &)*arg2,arg3);
86620     } catch (std::out_of_range& e) {
86621       {
86622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86623       };
86624     } catch (std::exception& e) {
86625       {
86626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86627       };
86628     } catch (Dali::DaliException e) {
86629       {
86630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86631       };
86632     } catch (...) {
86633       {
86634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86635       };
86636     }
86637   }
86638
86639   jresult = result;
86640
86641   //argout typemap for const std::string&
86642
86643   return jresult;
86644 }
86645
86646
86647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86648   unsigned int jresult ;
86649   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86650   std::string *arg2 = 0 ;
86651   Dali::ImageDimensions arg3 ;
86652   Dali::FittingMode::Type arg4 ;
86653   Dali::SamplingMode::Type arg5 ;
86654   bool arg6 ;
86655   Dali::ImageDimensions *argp3 ;
86656   uint32_t result;
86657
86658   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86659   if (!jarg2) {
86660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86661     return 0;
86662   }
86663   std::string arg2_str(jarg2);
86664   arg2 = &arg2_str;
86665   argp3 = (Dali::ImageDimensions *)jarg3;
86666   if (!argp3) {
86667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86668     return 0;
86669   }
86670   arg3 = *argp3;
86671   arg4 = (Dali::FittingMode::Type)jarg4;
86672   arg5 = (Dali::SamplingMode::Type)jarg5;
86673   arg6 = jarg6 ? true : false;
86674   {
86675     try {
86676       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86677     } catch (std::out_of_range& e) {
86678       {
86679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86680       };
86681     } catch (std::exception& e) {
86682       {
86683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86684       };
86685     } catch (Dali::DaliException e) {
86686       {
86687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86688       };
86689     } catch (...) {
86690       {
86691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86692       };
86693     }
86694   }
86695
86696   jresult = result;
86697
86698   //argout typemap for const std::string&
86699
86700   return jresult;
86701 }
86702
86703
86704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86705   unsigned int jresult ;
86706   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86707   uint32_t arg2 ;
86708   bool result;
86709
86710   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86711   arg2 = (uint32_t)jarg2;
86712   {
86713     try {
86714       result = (bool)(arg1)->Cancel(arg2);
86715     } catch (std::out_of_range& e) {
86716       {
86717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86718       };
86719     } catch (std::exception& e) {
86720       {
86721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86722       };
86723     } catch (Dali::DaliException e) {
86724       {
86725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86726       };
86727     } catch (...) {
86728       {
86729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86730       };
86731     }
86732   }
86733
86734   jresult = result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86740   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86741
86742   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86743   {
86744     try {
86745       (arg1)->CancelAll();
86746     } catch (std::out_of_range& e) {
86747       {
86748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86749       };
86750     } catch (std::exception& e) {
86751       {
86752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86753       };
86754     } catch (Dali::DaliException e) {
86755       {
86756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86757       };
86758     } catch (...) {
86759       {
86760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86761       };
86762     }
86763   }
86764
86765 }
86766
86767
86768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86769   void * jresult ;
86770   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86771   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86772
86773   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86774   {
86775     try {
86776       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86777     } catch (std::out_of_range& e) {
86778       {
86779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86780       };
86781     } catch (std::exception& e) {
86782       {
86783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86784       };
86785     } catch (Dali::DaliException e) {
86786       {
86787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86788       };
86789     } catch (...) {
86790       {
86791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86792       };
86793     }
86794   }
86795
86796   jresult = (void *)result;
86797   return jresult;
86798 }
86799
86800
86801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86802   void * jresult ;
86803   std::string *arg1 = 0 ;
86804   Dali::PixelData result;
86805
86806   if (!jarg1) {
86807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86808     return 0;
86809   }
86810   std::string arg1_str(jarg1);
86811   arg1 = &arg1_str;
86812   {
86813     try {
86814       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86815     } catch (std::out_of_range& e) {
86816       {
86817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (std::exception& e) {
86820       {
86821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (Dali::DaliException e) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86830       };
86831     }
86832   }
86833
86834   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86835
86836   //argout typemap for const std::string&
86837
86838   return jresult;
86839 }
86840
86841
86842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86843   void * jresult ;
86844   std::string *arg1 = 0 ;
86845   Dali::ImageDimensions arg2 ;
86846   Dali::ImageDimensions *argp2 ;
86847   Dali::PixelData result;
86848
86849   if (!jarg1) {
86850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86851     return 0;
86852   }
86853   std::string arg1_str(jarg1);
86854   arg1 = &arg1_str;
86855   argp2 = (Dali::ImageDimensions *)jarg2;
86856   if (!argp2) {
86857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86858     return 0;
86859   }
86860   arg2 = *argp2;
86861   {
86862     try {
86863       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86864     } catch (std::out_of_range& e) {
86865       {
86866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86867       };
86868     } catch (std::exception& e) {
86869       {
86870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86871       };
86872     } catch (Dali::DaliException e) {
86873       {
86874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86875       };
86876     } catch (...) {
86877       {
86878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86879       };
86880     }
86881   }
86882
86883   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86884
86885   //argout typemap for const std::string&
86886
86887   return jresult;
86888 }
86889
86890
86891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86892   void * jresult ;
86893   std::string *arg1 = 0 ;
86894   Dali::ImageDimensions arg2 ;
86895   Dali::FittingMode::Type arg3 ;
86896   Dali::SamplingMode::Type arg4 ;
86897   bool arg5 ;
86898   Dali::ImageDimensions *argp2 ;
86899   Dali::PixelData result;
86900
86901   if (!jarg1) {
86902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86903     return 0;
86904   }
86905   std::string arg1_str(jarg1);
86906   arg1 = &arg1_str;
86907   argp2 = (Dali::ImageDimensions *)jarg2;
86908   if (!argp2) {
86909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86910     return 0;
86911   }
86912   arg2 = *argp2;
86913   arg3 = (Dali::FittingMode::Type)jarg3;
86914   arg4 = (Dali::SamplingMode::Type)jarg4;
86915   arg5 = jarg5 ? true : false;
86916   {
86917     try {
86918       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86919     } catch (std::out_of_range& e) {
86920       {
86921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86922       };
86923     } catch (std::exception& e) {
86924       {
86925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86926       };
86927     } catch (Dali::DaliException e) {
86928       {
86929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86930       };
86931     } catch (...) {
86932       {
86933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86934       };
86935     }
86936   }
86937
86938   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86939
86940   //argout typemap for const std::string&
86941
86942   return jresult;
86943 }
86944
86945
86946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86947   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86948
86949   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86950   {
86951     try {
86952       delete arg1;
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86968       };
86969     }
86970   }
86971
86972 }
86973
86974
86975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86976   void * jresult ;
86977   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86978   Dali::Actor arg2 ;
86979   Dali::Actor arg3 ;
86980   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86981   Dali::Actor *argp2 ;
86982   Dali::Actor *argp3 ;
86983   Dali::Actor result;
86984
86985   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86986   argp2 = (Dali::Actor *)jarg2;
86987   if (!argp2) {
86988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86989     return 0;
86990   }
86991   arg2 = *argp2;
86992   argp3 = (Dali::Actor *)jarg3;
86993   if (!argp3) {
86994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86995     return 0;
86996   }
86997   arg3 = *argp3;
86998   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86999   {
87000     try {
87001       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87009       };
87010     } catch (Dali::DaliException e) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87013       };
87014     } catch (...) {
87015       {
87016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87017       };
87018     }
87019   }
87020
87021   jresult = new Dali::Actor((const Dali::Actor &)result);
87022   return jresult;
87023 }
87024
87025
87026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87027   void * jresult ;
87028   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87029
87030   {
87031     try {
87032       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87033     } catch (std::out_of_range& e) {
87034       {
87035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87036       };
87037     } catch (std::exception& e) {
87038       {
87039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87040       };
87041     } catch (Dali::DaliException e) {
87042       {
87043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87048       };
87049     }
87050   }
87051
87052   jresult = (void *)result;
87053   return jresult;
87054 }
87055
87056
87057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87058   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87059   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87060   if (director) {
87061     director->swig_connect_director(callback0);
87062   }
87063 }
87064
87065
87066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87067   void * jresult ;
87068   Dali::FrameCallbackInterface *result = 0 ;
87069
87070   {
87071     try {
87072       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87073     } catch (std::out_of_range& e) {
87074       {
87075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87076       };
87077     } catch (std::exception& e) {
87078       {
87079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87080       };
87081     } catch (Dali::DaliException e) {
87082       {
87083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87084       };
87085     } catch (...) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87088       };
87089     }
87090   }
87091
87092   jresult = (void *)result;
87093   return jresult;
87094 }
87095
87096 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87097   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87098   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87099   return proxy->GetPosition(id, *vector3);
87100 }
87101
87102 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87103   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87104   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87105   return proxy->SetPosition(id, *vector3);
87106 }
87107
87108 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87109   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87110   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87111   return proxy->BakePosition(id, *vector3);
87112 }
87113
87114 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87115   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87116   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87117   return proxy->GetSize(id, *vector3);
87118 }
87119
87120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87121   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87122   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87123   return proxy->SetSize(id, *vector3);
87124 }
87125 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87126   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87127   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87128   return proxy->BakeSize(id, *vector3);
87129 }
87130
87131 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87132   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87133   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87134   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87135   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87136 }
87137
87138 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87139   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87140   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87141   return proxy->GetScale(id,* vector3);
87142 }
87143
87144 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87145   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87146   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87147   return proxy->SetScale(id, *vector3);
87148 }
87149
87150 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87151   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87152   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87153   return proxy->BakeScale(id, *vector3);
87154 }
87155
87156 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87157   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87158   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87159   return proxy->GetColor(id, *vector4);
87160 }
87161
87162 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87163   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87164   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87165   return proxy->SetColor(id, *vector4);
87166 }
87167
87168 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87169   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87170   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87171   return proxy->BakeColor(id, *vector4);
87172 }
87173
87174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87175   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87176   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87177
87178   Dali::Stage *arg1 = (Dali::Stage *) 0;
87179   Dali::Actor *arg3 = 0;
87180
87181   arg1 = (Dali::Stage *)jarg1;
87182   arg3 = (Dali::Actor *)jarg3;
87183
87184   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87185   return;
87186 }
87187
87188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87189
87190   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87191   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87192
87193   Dali::Stage *arg1 = (Dali::Stage *) 0;
87194
87195   arg1 = (Dali::Stage *)jarg1;
87196
87197   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87198   return;
87199 }
87200
87201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87202   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87203   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87204   if (director) {
87205     director->swig_connect_director(callback0);
87206   }
87207 }
87208
87209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87210   KeyboardFocusManager arg1 ;
87211   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87212   KeyboardFocusManager *argp1 ;
87213
87214   argp1 = (KeyboardFocusManager *)jarg1;
87215   if (!argp1) {
87216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87217     return ;
87218   }
87219   arg1 = *argp1;
87220   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87221   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87222   {
87223     try {
87224       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87225     } catch (std::out_of_range& e) {
87226       {
87227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (std::exception& e) {
87230       {
87231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87232       };
87233     } catch (Dali::DaliException e) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87236       };
87237     } catch (...) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87240       };
87241     }
87242   }
87243
87244 }
87245
87246
87247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87248   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87249
87250   arg1 = (std::vector< unsigned int > *)jarg1;
87251   {
87252     try {
87253       (arg1)->clear();
87254     } catch (std::out_of_range& e) {
87255       {
87256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87257       };
87258     } catch (std::exception& e) {
87259       {
87260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87261       };
87262     } catch (Dali::DaliException e) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87265       };
87266     } catch (...) {
87267       {
87268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87269       };
87270     }
87271   }
87272
87273 }
87274
87275
87276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87277   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87278   unsigned int *arg2 = 0 ;
87279   unsigned int temp2 ;
87280
87281   arg1 = (std::vector< unsigned int > *)jarg1;
87282   temp2 = (unsigned int)jarg2;
87283   arg2 = &temp2;
87284   {
87285     try {
87286       (arg1)->push_back((unsigned int const &)*arg2);
87287     } catch (std::out_of_range& e) {
87288       {
87289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87290       };
87291     } catch (std::exception& e) {
87292       {
87293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87294       };
87295     } catch (Dali::DaliException e) {
87296       {
87297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87298       };
87299     } catch (...) {
87300       {
87301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87302       };
87303     }
87304   }
87305
87306 }
87307
87308
87309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87310   unsigned long jresult ;
87311   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87312   std::vector< unsigned int >::size_type result;
87313
87314   arg1 = (std::vector< unsigned int > *)jarg1;
87315   {
87316     try {
87317       result = ((std::vector< unsigned int > const *)arg1)->size();
87318     } catch (std::out_of_range& e) {
87319       {
87320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87321       };
87322     } catch (std::exception& e) {
87323       {
87324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87325       };
87326     } catch (Dali::DaliException e) {
87327       {
87328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87329       };
87330     } catch (...) {
87331       {
87332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87333       };
87334     }
87335   }
87336
87337   jresult = (unsigned long)result;
87338   return jresult;
87339 }
87340
87341
87342 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87343   unsigned long jresult ;
87344   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87345   std::vector< unsigned int >::size_type result;
87346
87347   arg1 = (std::vector< unsigned int > *)jarg1;
87348   {
87349     try {
87350       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87351     } catch (std::out_of_range& e) {
87352       {
87353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87354       };
87355     } catch (std::exception& e) {
87356       {
87357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87358       };
87359     } catch (Dali::DaliException e) {
87360       {
87361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87362       };
87363     } catch (...) {
87364       {
87365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87366       };
87367     }
87368   }
87369
87370   jresult = (unsigned long)result;
87371   return jresult;
87372 }
87373
87374
87375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87376   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87377   std::vector< unsigned int >::size_type arg2 ;
87378
87379   arg1 = (std::vector< unsigned int > *)jarg1;
87380   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87381   {
87382     try {
87383       (arg1)->reserve(arg2);
87384     } catch (std::out_of_range& e) {
87385       {
87386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87387       };
87388     } catch (std::exception& e) {
87389       {
87390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87391       };
87392     } catch (Dali::DaliException e) {
87393       {
87394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87395       };
87396     } catch (...) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87399       };
87400     }
87401   }
87402
87403 }
87404
87405
87406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87407   void * jresult ;
87408   std::vector< unsigned int > *result = 0 ;
87409
87410   {
87411     try {
87412       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87413     } catch (std::out_of_range& e) {
87414       {
87415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87416       };
87417     } catch (std::exception& e) {
87418       {
87419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87420       };
87421     } catch (Dali::DaliException e) {
87422       {
87423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87424       };
87425     } catch (...) {
87426       {
87427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87428       };
87429     }
87430   }
87431
87432   jresult = (void *)result;
87433   return jresult;
87434 }
87435
87436
87437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87438   void * jresult ;
87439   std::vector< unsigned int > *arg1 = 0 ;
87440   std::vector< unsigned int > *result = 0 ;
87441
87442   arg1 = (std::vector< unsigned int > *)jarg1;
87443   if (!arg1) {
87444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87445     return 0;
87446   }
87447   {
87448     try {
87449       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87450     } catch (std::out_of_range& e) {
87451       {
87452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (std::exception& e) {
87455       {
87456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87457       };
87458     } catch (Dali::DaliException e) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87461       };
87462     } catch (...) {
87463       {
87464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87465       };
87466     }
87467   }
87468
87469   jresult = (void *)result;
87470   return jresult;
87471 }
87472
87473
87474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87475   void * jresult ;
87476   int arg1 ;
87477   std::vector< unsigned int > *result = 0 ;
87478
87479   arg1 = (int)jarg1;
87480   {
87481     try {
87482       try {
87483         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87484       }
87485       catch(std::out_of_range &_e) {
87486         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87487         return 0;
87488       }
87489
87490     } catch (std::out_of_range& e) {
87491       {
87492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87493       };
87494     } catch (std::exception& e) {
87495       {
87496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87497       };
87498     } catch (Dali::DaliException e) {
87499       {
87500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87501       };
87502     } catch (...) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87505       };
87506     }
87507   }
87508
87509   jresult = (void *)result;
87510   return jresult;
87511 }
87512
87513
87514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87515   unsigned int jresult ;
87516   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87517   int arg2 ;
87518   unsigned int result;
87519
87520   arg1 = (std::vector< unsigned int > *)jarg1;
87521   arg2 = (int)jarg2;
87522   {
87523     try {
87524       try {
87525         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87526       }
87527       catch(std::out_of_range &_e) {
87528         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87529         return 0;
87530       }
87531
87532     } catch (std::out_of_range& e) {
87533       {
87534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87535       };
87536     } catch (std::exception& e) {
87537       {
87538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87539       };
87540     } catch (Dali::DaliException e) {
87541       {
87542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87543       };
87544     } catch (...) {
87545       {
87546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87547       };
87548     }
87549   }
87550
87551   jresult = result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87557   unsigned int jresult ;
87558   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87559   int arg2 ;
87560   unsigned int *result = 0 ;
87561
87562   arg1 = (std::vector< unsigned int > *)jarg1;
87563   arg2 = (int)jarg2;
87564   {
87565     try {
87566       try {
87567         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87568       }
87569       catch(std::out_of_range &_e) {
87570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87571         return 0;
87572       }
87573
87574     } catch (std::out_of_range& e) {
87575       {
87576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87577       };
87578     } catch (std::exception& e) {
87579       {
87580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87581       };
87582     } catch (Dali::DaliException e) {
87583       {
87584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87585       };
87586     } catch (...) {
87587       {
87588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87589       };
87590     }
87591   }
87592
87593   jresult = *result;
87594   return jresult;
87595 }
87596
87597
87598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87599   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87600   int arg2 ;
87601   unsigned int *arg3 = 0 ;
87602   unsigned int temp3 ;
87603
87604   arg1 = (std::vector< unsigned int > *)jarg1;
87605   arg2 = (int)jarg2;
87606   temp3 = (unsigned int)jarg3;
87607   arg3 = &temp3;
87608   {
87609     try {
87610       try {
87611         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87612       }
87613       catch(std::out_of_range &_e) {
87614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87615         return ;
87616       }
87617
87618     } catch (std::out_of_range& e) {
87619       {
87620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87621       };
87622     } catch (std::exception& e) {
87623       {
87624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87625       };
87626     } catch (Dali::DaliException e) {
87627       {
87628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87629       };
87630     } catch (...) {
87631       {
87632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87633       };
87634     }
87635   }
87636
87637 }
87638
87639
87640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87641   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87642   std::vector< unsigned int > *arg2 = 0 ;
87643
87644   arg1 = (std::vector< unsigned int > *)jarg1;
87645   arg2 = (std::vector< unsigned int > *)jarg2;
87646   if (!arg2) {
87647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87648     return ;
87649   }
87650   {
87651     try {
87652       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87653     } catch (std::out_of_range& e) {
87654       {
87655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87656       };
87657     } catch (std::exception& e) {
87658       {
87659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87660       };
87661     } catch (Dali::DaliException e) {
87662       {
87663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87668       };
87669     }
87670   }
87671
87672 }
87673
87674
87675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87676   void * jresult ;
87677   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87678   int arg2 ;
87679   int arg3 ;
87680   std::vector< unsigned int > *result = 0 ;
87681
87682   arg1 = (std::vector< unsigned int > *)jarg1;
87683   arg2 = (int)jarg2;
87684   arg3 = (int)jarg3;
87685   {
87686     try {
87687       try {
87688         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87689       }
87690       catch(std::out_of_range &_e) {
87691         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87692         return 0;
87693       }
87694       catch(std::invalid_argument &_e) {
87695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87696         return 0;
87697       }
87698
87699     } catch (std::out_of_range& e) {
87700       {
87701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87702       };
87703     } catch (std::exception& e) {
87704       {
87705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87706       };
87707     } catch (Dali::DaliException e) {
87708       {
87709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87710       };
87711     } catch (...) {
87712       {
87713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87714       };
87715     }
87716   }
87717
87718   jresult = (void *)result;
87719   return jresult;
87720 }
87721
87722
87723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87724   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87725   int arg2 ;
87726   unsigned int *arg3 = 0 ;
87727   unsigned int temp3 ;
87728
87729   arg1 = (std::vector< unsigned int > *)jarg1;
87730   arg2 = (int)jarg2;
87731   temp3 = (unsigned int)jarg3;
87732   arg3 = &temp3;
87733   {
87734     try {
87735       try {
87736         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87737       }
87738       catch(std::out_of_range &_e) {
87739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87740         return ;
87741       }
87742
87743     } catch (std::out_of_range& e) {
87744       {
87745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87746       };
87747     } catch (std::exception& e) {
87748       {
87749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87750       };
87751     } catch (Dali::DaliException e) {
87752       {
87753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87754       };
87755     } catch (...) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87758       };
87759     }
87760   }
87761
87762 }
87763
87764
87765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87766   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87767   int arg2 ;
87768   std::vector< unsigned int > *arg3 = 0 ;
87769
87770   arg1 = (std::vector< unsigned int > *)jarg1;
87771   arg2 = (int)jarg2;
87772   arg3 = (std::vector< unsigned int > *)jarg3;
87773   if (!arg3) {
87774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87775     return ;
87776   }
87777   {
87778     try {
87779       try {
87780         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87781       }
87782       catch(std::out_of_range &_e) {
87783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87784         return ;
87785       }
87786
87787     } catch (std::out_of_range& e) {
87788       {
87789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87790       };
87791     } catch (std::exception& e) {
87792       {
87793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87794       };
87795     } catch (Dali::DaliException e) {
87796       {
87797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87798       };
87799     } catch (...) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87802       };
87803     }
87804   }
87805
87806 }
87807
87808
87809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87810   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87811   int arg2 ;
87812
87813   arg1 = (std::vector< unsigned int > *)jarg1;
87814   arg2 = (int)jarg2;
87815   {
87816     try {
87817       try {
87818         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87819       }
87820       catch(std::out_of_range &_e) {
87821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87822         return ;
87823       }
87824
87825     } catch (std::out_of_range& e) {
87826       {
87827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87828       };
87829     } catch (std::exception& e) {
87830       {
87831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87832       };
87833     } catch (Dali::DaliException e) {
87834       {
87835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87836       };
87837     } catch (...) {
87838       {
87839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87840       };
87841     }
87842   }
87843
87844 }
87845
87846
87847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87848   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87849   int arg2 ;
87850   int arg3 ;
87851
87852   arg1 = (std::vector< unsigned int > *)jarg1;
87853   arg2 = (int)jarg2;
87854   arg3 = (int)jarg3;
87855   {
87856     try {
87857       try {
87858         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87859       }
87860       catch(std::out_of_range &_e) {
87861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87862         return ;
87863       }
87864       catch(std::invalid_argument &_e) {
87865         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87866         return ;
87867       }
87868
87869     } catch (std::out_of_range& e) {
87870       {
87871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87872       };
87873     } catch (std::exception& e) {
87874       {
87875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87876       };
87877     } catch (Dali::DaliException e) {
87878       {
87879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87880       };
87881     } catch (...) {
87882       {
87883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87884       };
87885     }
87886   }
87887
87888 }
87889
87890
87891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87892   void * jresult ;
87893   unsigned int *arg1 = 0 ;
87894   int arg2 ;
87895   unsigned int temp1 ;
87896   std::vector< unsigned int > *result = 0 ;
87897
87898   temp1 = (unsigned int)jarg1;
87899   arg1 = &temp1;
87900   arg2 = (int)jarg2;
87901   {
87902     try {
87903       try {
87904         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87905       }
87906       catch(std::out_of_range &_e) {
87907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_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_Reverse__SWIG_0(void * jarg1) {
87936   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87937
87938   arg1 = (std::vector< unsigned int > *)jarg1;
87939   {
87940     try {
87941       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87942     } catch (std::out_of_range& e) {
87943       {
87944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87945       };
87946     } catch (std::exception& e) {
87947       {
87948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87949       };
87950     } catch (Dali::DaliException e) {
87951       {
87952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87953       };
87954     } catch (...) {
87955       {
87956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87957       };
87958     }
87959   }
87960
87961 }
87962
87963
87964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87965   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87966   int arg2 ;
87967   int arg3 ;
87968
87969   arg1 = (std::vector< unsigned int > *)jarg1;
87970   arg2 = (int)jarg2;
87971   arg3 = (int)jarg3;
87972   {
87973     try {
87974       try {
87975         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87976       }
87977       catch(std::out_of_range &_e) {
87978         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87979         return ;
87980       }
87981       catch(std::invalid_argument &_e) {
87982         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87983         return ;
87984       }
87985
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87993       };
87994     } catch (Dali::DaliException e) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87997       };
87998     } catch (...) {
87999       {
88000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88001       };
88002     }
88003   }
88004
88005 }
88006
88007
88008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88009   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88010   int arg2 ;
88011   std::vector< unsigned int > *arg3 = 0 ;
88012
88013   arg1 = (std::vector< unsigned int > *)jarg1;
88014   arg2 = (int)jarg2;
88015   arg3 = (std::vector< unsigned int > *)jarg3;
88016   if (!arg3) {
88017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88018     return ;
88019   }
88020   {
88021     try {
88022       try {
88023         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88024       }
88025       catch(std::out_of_range &_e) {
88026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88027         return ;
88028       }
88029
88030     } catch (std::out_of_range& e) {
88031       {
88032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88033       };
88034     } catch (std::exception& e) {
88035       {
88036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88037       };
88038     } catch (Dali::DaliException e) {
88039       {
88040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88041       };
88042     } catch (...) {
88043       {
88044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88045       };
88046     }
88047   }
88048
88049 }
88050
88051
88052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88053   unsigned int jresult ;
88054   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88055   unsigned int *arg2 = 0 ;
88056   unsigned int temp2 ;
88057   bool result;
88058
88059   arg1 = (std::vector< unsigned int > *)jarg1;
88060   temp2 = (unsigned int)jarg2;
88061   arg2 = &temp2;
88062   {
88063     try {
88064       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88080       };
88081     }
88082   }
88083
88084   jresult = result;
88085   return jresult;
88086 }
88087
88088
88089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88090   int jresult ;
88091   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88092   unsigned int *arg2 = 0 ;
88093   unsigned int temp2 ;
88094   int result;
88095
88096   arg1 = (std::vector< unsigned int > *)jarg1;
88097   temp2 = (unsigned int)jarg2;
88098   arg2 = &temp2;
88099   {
88100     try {
88101       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88102     } catch (std::out_of_range& e) {
88103       {
88104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88105       };
88106     } catch (std::exception& e) {
88107       {
88108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88109       };
88110     } catch (Dali::DaliException e) {
88111       {
88112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88113       };
88114     } catch (...) {
88115       {
88116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88117       };
88118     }
88119   }
88120
88121   jresult = result;
88122   return jresult;
88123 }
88124
88125
88126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88127   int jresult ;
88128   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88129   unsigned int *arg2 = 0 ;
88130   unsigned int temp2 ;
88131   int result;
88132
88133   arg1 = (std::vector< unsigned int > *)jarg1;
88134   temp2 = (unsigned int)jarg2;
88135   arg2 = &temp2;
88136   {
88137     try {
88138       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88139     } catch (std::out_of_range& e) {
88140       {
88141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88142       };
88143     } catch (std::exception& e) {
88144       {
88145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88146       };
88147     } catch (Dali::DaliException e) {
88148       {
88149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88150       };
88151     } catch (...) {
88152       {
88153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88154       };
88155     }
88156   }
88157
88158   jresult = result;
88159   return jresult;
88160 }
88161
88162
88163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88164   unsigned int jresult ;
88165   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88166   unsigned int *arg2 = 0 ;
88167   unsigned int temp2 ;
88168   bool result;
88169
88170   arg1 = (std::vector< unsigned int > *)jarg1;
88171   temp2 = (unsigned int)jarg2;
88172   arg2 = &temp2;
88173   {
88174     try {
88175       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88176     } catch (std::out_of_range& e) {
88177       {
88178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88179       };
88180     } catch (std::exception& e) {
88181       {
88182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88183       };
88184     } catch (Dali::DaliException e) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88187       };
88188     } catch (...) {
88189       {
88190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88191       };
88192     }
88193   }
88194
88195   jresult = result;
88196   return jresult;
88197 }
88198
88199
88200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88201   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88202
88203   arg1 = (std::vector< unsigned int > *)jarg1;
88204   {
88205     try {
88206       delete arg1;
88207     } catch (std::out_of_range& e) {
88208       {
88209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88210       };
88211     } catch (std::exception& e) {
88212       {
88213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88214       };
88215     } catch (Dali::DaliException e) {
88216       {
88217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88218       };
88219     } catch (...) {
88220       {
88221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88222       };
88223     }
88224   }
88225
88226 }
88227
88228
88229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88230   void * jresult ;
88231   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88232
88233   {
88234     try {
88235       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88236     } catch (std::out_of_range& e) {
88237       {
88238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (std::exception& e) {
88241       {
88242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88243       };
88244     } catch (Dali::DaliException e) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88247       };
88248     } catch (...) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88251       };
88252     }
88253   }
88254
88255   jresult = (void *)result;
88256   return jresult;
88257 }
88258
88259
88260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88261   void * jresult ;
88262   unsigned int arg1 ;
88263   Dali::Actor arg2 ;
88264   Dali::Actor *argp2 ;
88265   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88266
88267   arg1 = (unsigned int)jarg1;
88268   argp2 = (Dali::Actor *)jarg2;
88269   if (!argp2) {
88270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88271     return 0;
88272   }
88273   arg2 = *argp2;
88274   {
88275     try {
88276       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,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 = (void *)result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88302   void * jresult ;
88303   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88304   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88305
88306   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88307   if (!arg1) {
88308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88309     return 0;
88310   }
88311   {
88312     try {
88313       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
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 = (void *)result;
88334   return jresult;
88335 }
88336
88337
88338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88339   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88340   unsigned int arg2 ;
88341
88342   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88343   arg2 = (unsigned int)jarg2;
88344   if (arg1) (arg1)->first = arg2;
88345 }
88346
88347
88348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88349   unsigned int jresult ;
88350   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88351   unsigned int result;
88352
88353   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88354   result = (unsigned int) ((arg1)->first);
88355   jresult = result;
88356   return jresult;
88357 }
88358
88359
88360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88361   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88362   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88363
88364   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88365   arg2 = (Dali::Actor *)jarg2;
88366   if (arg1) (arg1)->second = *arg2;
88367 }
88368
88369
88370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88371   void * jresult ;
88372   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88373   Dali::Actor *result = 0 ;
88374
88375   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88376   result = (Dali::Actor *)& ((arg1)->second);
88377   jresult = (void *)result;
88378   return jresult;
88379 }
88380
88381
88382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88383   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88384
88385   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88386   {
88387     try {
88388       delete arg1;
88389     } catch (std::out_of_range& e) {
88390       {
88391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88392       };
88393     } catch (std::exception& e) {
88394       {
88395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88396       };
88397     } catch (Dali::DaliException e) {
88398       {
88399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88400       };
88401     } catch (...) {
88402       {
88403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88404       };
88405     }
88406   }
88407
88408 }
88409
88410
88411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88412   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88413
88414   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88415   {
88416     try {
88417       (arg1)->clear();
88418     } catch (std::out_of_range& e) {
88419       {
88420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88421       };
88422     } catch (std::exception& e) {
88423       {
88424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88425       };
88426     } catch (Dali::DaliException e) {
88427       {
88428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88429       };
88430     } catch (...) {
88431       {
88432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88433       };
88434     }
88435   }
88436
88437 }
88438
88439
88440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88441   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88442   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88443
88444   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88445   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88446   if (!arg2) {
88447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88448     return ;
88449   }
88450   {
88451     try {
88452       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88453     } catch (std::out_of_range& e) {
88454       {
88455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88456       };
88457     } catch (std::exception& e) {
88458       {
88459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88460       };
88461     } catch (Dali::DaliException e) {
88462       {
88463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88464       };
88465     } catch (...) {
88466       {
88467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88468       };
88469     }
88470   }
88471
88472 }
88473
88474
88475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88476   unsigned long jresult ;
88477   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88478   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88479
88480   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88481   {
88482     try {
88483       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88484     } catch (std::out_of_range& e) {
88485       {
88486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88487       };
88488     } catch (std::exception& e) {
88489       {
88490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88491       };
88492     } catch (Dali::DaliException e) {
88493       {
88494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88495       };
88496     } catch (...) {
88497       {
88498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88499       };
88500     }
88501   }
88502
88503   jresult = (unsigned long)result;
88504   return jresult;
88505 }
88506
88507
88508 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88509   unsigned long jresult ;
88510   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88511   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88512
88513   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88514   {
88515     try {
88516       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88517     } catch (std::out_of_range& e) {
88518       {
88519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88520       };
88521     } catch (std::exception& e) {
88522       {
88523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88524       };
88525     } catch (Dali::DaliException e) {
88526       {
88527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88528       };
88529     } catch (...) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88532       };
88533     }
88534   }
88535
88536   jresult = (unsigned long)result;
88537   return jresult;
88538 }
88539
88540
88541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88542   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88543   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88544
88545   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88546   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88547   {
88548     try {
88549       (arg1)->reserve(arg2);
88550     } catch (std::out_of_range& e) {
88551       {
88552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88553       };
88554     } catch (std::exception& e) {
88555       {
88556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88557       };
88558     } catch (Dali::DaliException e) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88561       };
88562     } catch (...) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88565       };
88566     }
88567   }
88568
88569 }
88570
88571
88572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88573   void * jresult ;
88574   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88575
88576   {
88577     try {
88578       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88579     } catch (std::out_of_range& e) {
88580       {
88581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88582       };
88583     } catch (std::exception& e) {
88584       {
88585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88586       };
88587     } catch (Dali::DaliException e) {
88588       {
88589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88590       };
88591     } catch (...) {
88592       {
88593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88594       };
88595     }
88596   }
88597
88598   jresult = (void *)result;
88599   return jresult;
88600 }
88601
88602
88603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88604   void * jresult ;
88605   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88606   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88607
88608   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88609   if (!arg1) {
88610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88611     return 0;
88612   }
88613   {
88614     try {
88615       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);
88616     } catch (std::out_of_range& e) {
88617       {
88618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88619       };
88620     } catch (std::exception& e) {
88621       {
88622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88623       };
88624     } catch (Dali::DaliException e) {
88625       {
88626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88627       };
88628     } catch (...) {
88629       {
88630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88631       };
88632     }
88633   }
88634
88635   jresult = (void *)result;
88636   return jresult;
88637 }
88638
88639
88640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88641   void * jresult ;
88642   int arg1 ;
88643   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88644
88645   arg1 = (int)jarg1;
88646   {
88647     try {
88648       try {
88649         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);
88650       }
88651       catch(std::out_of_range &_e) {
88652         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88653         return 0;
88654       }
88655
88656     } catch (std::out_of_range& e) {
88657       {
88658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88659       };
88660     } catch (std::exception& e) {
88661       {
88662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88663       };
88664     } catch (Dali::DaliException e) {
88665       {
88666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88667       };
88668     } catch (...) {
88669       {
88670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88671       };
88672     }
88673   }
88674
88675   jresult = (void *)result;
88676   return jresult;
88677 }
88678
88679
88680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88681   void * jresult ;
88682   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88683   int arg2 ;
88684   std::pair< unsigned int,Dali::Actor > result;
88685
88686   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88687   arg2 = (int)jarg2;
88688   {
88689     try {
88690       try {
88691         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88692       }
88693       catch(std::out_of_range &_e) {
88694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88695         return 0;
88696       }
88697
88698     } catch (std::out_of_range& e) {
88699       {
88700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88701       };
88702     } catch (std::exception& e) {
88703       {
88704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88705       };
88706     } catch (Dali::DaliException e) {
88707       {
88708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88709       };
88710     } catch (...) {
88711       {
88712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88713       };
88714     }
88715   }
88716
88717   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88718   return jresult;
88719 }
88720
88721
88722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88723   void * jresult ;
88724   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88725   int arg2 ;
88726   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88727
88728   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88729   arg2 = (int)jarg2;
88730   {
88731     try {
88732       try {
88733         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88734       }
88735       catch(std::out_of_range &_e) {
88736         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88737         return 0;
88738       }
88739
88740     } catch (std::out_of_range& e) {
88741       {
88742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88743       };
88744     } catch (std::exception& e) {
88745       {
88746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (Dali::DaliException e) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88751       };
88752     } catch (...) {
88753       {
88754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88755       };
88756     }
88757   }
88758
88759   jresult = (void *)result;
88760   return jresult;
88761 }
88762
88763
88764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88765   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88766   int arg2 ;
88767   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88768
88769   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88770   arg2 = (int)jarg2;
88771   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88772   if (!arg3) {
88773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88774     return ;
88775   }
88776   {
88777     try {
88778       try {
88779         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);
88780       }
88781       catch(std::out_of_range &_e) {
88782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88783         return ;
88784       }
88785
88786     } catch (std::out_of_range& e) {
88787       {
88788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88789       };
88790     } catch (std::exception& e) {
88791       {
88792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88793       };
88794     } catch (Dali::DaliException e) {
88795       {
88796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88797       };
88798     } catch (...) {
88799       {
88800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88801       };
88802     }
88803   }
88804
88805 }
88806
88807
88808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88809   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88810   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88811
88812   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88813   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88814   if (!arg2) {
88815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88816     return ;
88817   }
88818   {
88819     try {
88820       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);
88821     } catch (std::out_of_range& e) {
88822       {
88823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88824       };
88825     } catch (std::exception& e) {
88826       {
88827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88828       };
88829     } catch (Dali::DaliException e) {
88830       {
88831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88832       };
88833     } catch (...) {
88834       {
88835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88836       };
88837     }
88838   }
88839
88840 }
88841
88842
88843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88844   void * jresult ;
88845   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88846   int arg2 ;
88847   int arg3 ;
88848   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88849
88850   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88851   arg2 = (int)jarg2;
88852   arg3 = (int)jarg3;
88853   {
88854     try {
88855       try {
88856         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);
88857       }
88858       catch(std::out_of_range &_e) {
88859         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88860         return 0;
88861       }
88862       catch(std::invalid_argument &_e) {
88863         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88864         return 0;
88865       }
88866
88867     } catch (std::out_of_range& e) {
88868       {
88869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88870       };
88871     } catch (std::exception& e) {
88872       {
88873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88874       };
88875     } catch (Dali::DaliException e) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88878       };
88879     } catch (...) {
88880       {
88881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88882       };
88883     }
88884   }
88885
88886   jresult = (void *)result;
88887   return jresult;
88888 }
88889
88890
88891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88892   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88893   int arg2 ;
88894   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88895
88896   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88897   arg2 = (int)jarg2;
88898   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88899   if (!arg3) {
88900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88901     return ;
88902   }
88903   {
88904     try {
88905       try {
88906         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);
88907       }
88908       catch(std::out_of_range &_e) {
88909         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88910         return ;
88911       }
88912
88913     } catch (std::out_of_range& e) {
88914       {
88915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88916       };
88917     } catch (std::exception& e) {
88918       {
88919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88920       };
88921     } catch (Dali::DaliException e) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88924       };
88925     } catch (...) {
88926       {
88927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88928       };
88929     }
88930   }
88931
88932 }
88933
88934
88935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88936   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88937   int arg2 ;
88938   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88939
88940   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88941   arg2 = (int)jarg2;
88942   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88943   if (!arg3) {
88944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88945     return ;
88946   }
88947   {
88948     try {
88949       try {
88950         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);
88951       }
88952       catch(std::out_of_range &_e) {
88953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88954         return ;
88955       }
88956
88957     } catch (std::out_of_range& e) {
88958       {
88959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88960       };
88961     } catch (std::exception& e) {
88962       {
88963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88964       };
88965     } catch (Dali::DaliException e) {
88966       {
88967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88968       };
88969     } catch (...) {
88970       {
88971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88972       };
88973     }
88974   }
88975
88976 }
88977
88978
88979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88980   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88981   int arg2 ;
88982
88983   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88984   arg2 = (int)jarg2;
88985   {
88986     try {
88987       try {
88988         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88989       }
88990       catch(std::out_of_range &_e) {
88991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88992         return ;
88993       }
88994
88995     } catch (std::out_of_range& e) {
88996       {
88997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88998       };
88999     } catch (std::exception& e) {
89000       {
89001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89002       };
89003     } catch (Dali::DaliException e) {
89004       {
89005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89006       };
89007     } catch (...) {
89008       {
89009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89010       };
89011     }
89012   }
89013
89014 }
89015
89016
89017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89018   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89019   int arg2 ;
89020   int arg3 ;
89021
89022   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89023   arg2 = (int)jarg2;
89024   arg3 = (int)jarg3;
89025   {
89026     try {
89027       try {
89028         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89029       }
89030       catch(std::out_of_range &_e) {
89031         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89032         return ;
89033       }
89034       catch(std::invalid_argument &_e) {
89035         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89036         return ;
89037       }
89038
89039     } catch (std::out_of_range& e) {
89040       {
89041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89042       };
89043     } catch (std::exception& e) {
89044       {
89045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (Dali::DaliException e) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89050       };
89051     } catch (...) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89054       };
89055     }
89056   }
89057
89058 }
89059
89060
89061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89062   void * jresult ;
89063   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89064   int arg2 ;
89065   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89066
89067   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89068   if (!arg1) {
89069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89070     return 0;
89071   }
89072   arg2 = (int)jarg2;
89073   {
89074     try {
89075       try {
89076         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);
89077       }
89078       catch(std::out_of_range &_e) {
89079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89080         return 0;
89081       }
89082
89083     } catch (std::out_of_range& e) {
89084       {
89085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89086       };
89087     } catch (std::exception& e) {
89088       {
89089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89090       };
89091     } catch (Dali::DaliException e) {
89092       {
89093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89094       };
89095     } catch (...) {
89096       {
89097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89098       };
89099     }
89100   }
89101
89102   jresult = (void *)result;
89103   return jresult;
89104 }
89105
89106
89107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89108   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89109
89110   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89111   {
89112     try {
89113       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89114     } catch (std::out_of_range& e) {
89115       {
89116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89117       };
89118     } catch (std::exception& e) {
89119       {
89120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89121       };
89122     } catch (Dali::DaliException e) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89125       };
89126     } catch (...) {
89127       {
89128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89129       };
89130     }
89131   }
89132
89133 }
89134
89135
89136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89137   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89138   int arg2 ;
89139   int arg3 ;
89140
89141   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89142   arg2 = (int)jarg2;
89143   arg3 = (int)jarg3;
89144   {
89145     try {
89146       try {
89147         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89148       }
89149       catch(std::out_of_range &_e) {
89150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89151         return ;
89152       }
89153       catch(std::invalid_argument &_e) {
89154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89155         return ;
89156       }
89157
89158     } catch (std::out_of_range& e) {
89159       {
89160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89161       };
89162     } catch (std::exception& e) {
89163       {
89164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89165       };
89166     } catch (Dali::DaliException e) {
89167       {
89168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89169       };
89170     } catch (...) {
89171       {
89172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89173       };
89174     }
89175   }
89176
89177 }
89178
89179
89180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89181   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89182   int arg2 ;
89183   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89184
89185   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89186   arg2 = (int)jarg2;
89187   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89188   if (!arg3) {
89189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89190     return ;
89191   }
89192   {
89193     try {
89194       try {
89195         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);
89196       }
89197       catch(std::out_of_range &_e) {
89198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89199         return ;
89200       }
89201
89202     } catch (std::out_of_range& e) {
89203       {
89204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89205       };
89206     } catch (std::exception& e) {
89207       {
89208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89209       };
89210     } catch (Dali::DaliException e) {
89211       {
89212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89213       };
89214     } catch (...) {
89215       {
89216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89217       };
89218     }
89219   }
89220
89221 }
89222
89223
89224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89225   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89226
89227   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89228   {
89229     try {
89230       delete arg1;
89231     } catch (std::out_of_range& e) {
89232       {
89233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89234       };
89235     } catch (std::exception& e) {
89236       {
89237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89238       };
89239     } catch (Dali::DaliException e) {
89240       {
89241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89242       };
89243     } catch (...) {
89244       {
89245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89246       };
89247     }
89248   }
89249
89250 }
89251
89252
89253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89254   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89255
89256   arg1 = (std::vector< Dali::Actor > *)jarg1;
89257   {
89258     try {
89259       (arg1)->clear();
89260     } catch (std::out_of_range& e) {
89261       {
89262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89263       };
89264     } catch (std::exception& e) {
89265       {
89266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89267       };
89268     } catch (Dali::DaliException e) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89271       };
89272     } catch (...) {
89273       {
89274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89275       };
89276     }
89277   }
89278
89279 }
89280
89281
89282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89283   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89284   Dali::Actor *arg2 = 0 ;
89285
89286   arg1 = (std::vector< Dali::Actor > *)jarg1;
89287   arg2 = (Dali::Actor *)jarg2;
89288   if (!arg2) {
89289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89290     return ;
89291   }
89292   {
89293     try {
89294       (arg1)->push_back((Dali::Actor const &)*arg2);
89295     } catch (std::out_of_range& e) {
89296       {
89297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89298       };
89299     } catch (std::exception& e) {
89300       {
89301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89302       };
89303     } catch (Dali::DaliException e) {
89304       {
89305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89306       };
89307     } catch (...) {
89308       {
89309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89310       };
89311     }
89312   }
89313
89314 }
89315
89316
89317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89318   unsigned long jresult ;
89319   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89320   std::vector< Dali::Actor >::size_type result;
89321
89322   arg1 = (std::vector< Dali::Actor > *)jarg1;
89323   {
89324     try {
89325       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89326     } catch (std::out_of_range& e) {
89327       {
89328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89329       };
89330     } catch (std::exception& e) {
89331       {
89332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89333       };
89334     } catch (Dali::DaliException e) {
89335       {
89336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89337       };
89338     } catch (...) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89341       };
89342     }
89343   }
89344
89345   jresult = (unsigned long)result;
89346   return jresult;
89347 }
89348
89349
89350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89351   unsigned long jresult ;
89352   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89353   std::vector< Dali::Actor >::size_type result;
89354
89355   arg1 = (std::vector< Dali::Actor > *)jarg1;
89356   {
89357     try {
89358       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89359     } catch (std::out_of_range& e) {
89360       {
89361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89362       };
89363     } catch (std::exception& e) {
89364       {
89365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89366       };
89367     } catch (Dali::DaliException e) {
89368       {
89369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89370       };
89371     } catch (...) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89374       };
89375     }
89376   }
89377
89378   jresult = (unsigned long)result;
89379   return jresult;
89380 }
89381
89382
89383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89384   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89385   std::vector< Dali::Actor >::size_type arg2 ;
89386
89387   arg1 = (std::vector< Dali::Actor > *)jarg1;
89388   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89389   {
89390     try {
89391       (arg1)->reserve(arg2);
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89399       };
89400     } catch (Dali::DaliException e) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89403       };
89404     } catch (...) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89407       };
89408     }
89409   }
89410
89411 }
89412
89413
89414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89415   void * jresult ;
89416   std::vector< Dali::Actor > *result = 0 ;
89417
89418   {
89419     try {
89420       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89421     } catch (std::out_of_range& e) {
89422       {
89423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89424       };
89425     } catch (std::exception& e) {
89426       {
89427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89428       };
89429     } catch (Dali::DaliException e) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89432       };
89433     } catch (...) {
89434       {
89435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89436       };
89437     }
89438   }
89439
89440   jresult = (void *)result;
89441   return jresult;
89442 }
89443
89444
89445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89446   void * jresult ;
89447   std::vector< Dali::Actor > *arg1 = 0 ;
89448   std::vector< Dali::Actor > *result = 0 ;
89449
89450   arg1 = (std::vector< Dali::Actor > *)jarg1;
89451   if (!arg1) {
89452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89453     return 0;
89454   }
89455   {
89456     try {
89457       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89458     } catch (std::out_of_range& e) {
89459       {
89460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89461       };
89462     } catch (std::exception& e) {
89463       {
89464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89465       };
89466     } catch (Dali::DaliException e) {
89467       {
89468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89469       };
89470     } catch (...) {
89471       {
89472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89473       };
89474     }
89475   }
89476
89477   jresult = (void *)result;
89478   return jresult;
89479 }
89480
89481
89482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89483   void * jresult ;
89484   int arg1 ;
89485   std::vector< Dali::Actor > *result = 0 ;
89486
89487   arg1 = (int)jarg1;
89488   {
89489     try {
89490       try {
89491         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89492       }
89493       catch(std::out_of_range &_e) {
89494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89495         return 0;
89496       }
89497
89498     } catch (std::out_of_range& e) {
89499       {
89500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89501       };
89502     } catch (std::exception& e) {
89503       {
89504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89505       };
89506     } catch (Dali::DaliException e) {
89507       {
89508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89509       };
89510     } catch (...) {
89511       {
89512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89513       };
89514     }
89515   }
89516
89517   jresult = (void *)result;
89518   return jresult;
89519 }
89520
89521
89522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89523   void * jresult ;
89524   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89525   int arg2 ;
89526   Dali::Actor result;
89527
89528   arg1 = (std::vector< Dali::Actor > *)jarg1;
89529   arg2 = (int)jarg2;
89530   {
89531     try {
89532       try {
89533         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89534       }
89535       catch(std::out_of_range &_e) {
89536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89537         return 0;
89538       }
89539
89540     } catch (std::out_of_range& e) {
89541       {
89542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89543       };
89544     } catch (std::exception& e) {
89545       {
89546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89547       };
89548     } catch (Dali::DaliException e) {
89549       {
89550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89551       };
89552     } catch (...) {
89553       {
89554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89555       };
89556     }
89557   }
89558
89559   jresult = new Dali::Actor((const Dali::Actor &)result);
89560   return jresult;
89561 }
89562
89563
89564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89565   void * jresult ;
89566   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89567   int arg2 ;
89568   Dali::Actor *result = 0 ;
89569
89570   arg1 = (std::vector< Dali::Actor > *)jarg1;
89571   arg2 = (int)jarg2;
89572   {
89573     try {
89574       try {
89575         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89576       }
89577       catch(std::out_of_range &_e) {
89578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89579         return 0;
89580       }
89581
89582     } catch (std::out_of_range& e) {
89583       {
89584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89585       };
89586     } catch (std::exception& e) {
89587       {
89588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (Dali::DaliException e) {
89591       {
89592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89593       };
89594     } catch (...) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89597       };
89598     }
89599   }
89600
89601   jresult = (void *)result;
89602   return jresult;
89603 }
89604
89605
89606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89607   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89608   int arg2 ;
89609   Dali::Actor *arg3 = 0 ;
89610
89611   arg1 = (std::vector< Dali::Actor > *)jarg1;
89612   arg2 = (int)jarg2;
89613   arg3 = (Dali::Actor *)jarg3;
89614   if (!arg3) {
89615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89616     return ;
89617   }
89618   {
89619     try {
89620       try {
89621         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89622       }
89623       catch(std::out_of_range &_e) {
89624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89625         return ;
89626       }
89627
89628     } catch (std::out_of_range& e) {
89629       {
89630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89631       };
89632     } catch (std::exception& e) {
89633       {
89634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89635       };
89636     } catch (Dali::DaliException e) {
89637       {
89638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89639       };
89640     } catch (...) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89643       };
89644     }
89645   }
89646
89647 }
89648
89649
89650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89651   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89652   std::vector< Dali::Actor > *arg2 = 0 ;
89653
89654   arg1 = (std::vector< Dali::Actor > *)jarg1;
89655   arg2 = (std::vector< Dali::Actor > *)jarg2;
89656   if (!arg2) {
89657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89658     return ;
89659   }
89660   {
89661     try {
89662       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89663     } catch (std::out_of_range& e) {
89664       {
89665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89666       };
89667     } catch (std::exception& e) {
89668       {
89669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89670       };
89671     } catch (Dali::DaliException e) {
89672       {
89673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89674       };
89675     } catch (...) {
89676       {
89677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89678       };
89679     }
89680   }
89681
89682 }
89683
89684
89685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89686   void * jresult ;
89687   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89688   int arg2 ;
89689   int arg3 ;
89690   std::vector< Dali::Actor > *result = 0 ;
89691
89692   arg1 = (std::vector< Dali::Actor > *)jarg1;
89693   arg2 = (int)jarg2;
89694   arg3 = (int)jarg3;
89695   {
89696     try {
89697       try {
89698         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89699       }
89700       catch(std::out_of_range &_e) {
89701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89702         return 0;
89703       }
89704       catch(std::invalid_argument &_e) {
89705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89706         return 0;
89707       }
89708
89709     } catch (std::out_of_range& e) {
89710       {
89711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89712       };
89713     } catch (std::exception& e) {
89714       {
89715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89716       };
89717     } catch (Dali::DaliException e) {
89718       {
89719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89720       };
89721     } catch (...) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89724       };
89725     }
89726   }
89727
89728   jresult = (void *)result;
89729   return jresult;
89730 }
89731
89732
89733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89734   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89735   int arg2 ;
89736   Dali::Actor *arg3 = 0 ;
89737
89738   arg1 = (std::vector< Dali::Actor > *)jarg1;
89739   arg2 = (int)jarg2;
89740   arg3 = (Dali::Actor *)jarg3;
89741   if (!arg3) {
89742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89743     return ;
89744   }
89745   {
89746     try {
89747       try {
89748         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89749       }
89750       catch(std::out_of_range &_e) {
89751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89752         return ;
89753       }
89754
89755     } catch (std::out_of_range& e) {
89756       {
89757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89758       };
89759     } catch (std::exception& e) {
89760       {
89761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89762       };
89763     } catch (Dali::DaliException e) {
89764       {
89765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89766       };
89767     } catch (...) {
89768       {
89769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89770       };
89771     }
89772   }
89773
89774 }
89775
89776
89777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89778   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89779   int arg2 ;
89780   std::vector< Dali::Actor > *arg3 = 0 ;
89781
89782   arg1 = (std::vector< Dali::Actor > *)jarg1;
89783   arg2 = (int)jarg2;
89784   arg3 = (std::vector< Dali::Actor > *)jarg3;
89785   if (!arg3) {
89786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89787     return ;
89788   }
89789   {
89790     try {
89791       try {
89792         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89793       }
89794       catch(std::out_of_range &_e) {
89795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89796         return ;
89797       }
89798
89799     } catch (std::out_of_range& e) {
89800       {
89801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89802       };
89803     } catch (std::exception& e) {
89804       {
89805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89806       };
89807     } catch (Dali::DaliException e) {
89808       {
89809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89810       };
89811     } catch (...) {
89812       {
89813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89814       };
89815     }
89816   }
89817
89818 }
89819
89820
89821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89822   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89823   int arg2 ;
89824
89825   arg1 = (std::vector< Dali::Actor > *)jarg1;
89826   arg2 = (int)jarg2;
89827   {
89828     try {
89829       try {
89830         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89831       }
89832       catch(std::out_of_range &_e) {
89833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89834         return ;
89835       }
89836
89837     } catch (std::out_of_range& e) {
89838       {
89839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89840       };
89841     } catch (std::exception& e) {
89842       {
89843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89844       };
89845     } catch (Dali::DaliException e) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89848       };
89849     } catch (...) {
89850       {
89851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89852       };
89853     }
89854   }
89855
89856 }
89857
89858
89859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89860   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89861   int arg2 ;
89862   int arg3 ;
89863
89864   arg1 = (std::vector< Dali::Actor > *)jarg1;
89865   arg2 = (int)jarg2;
89866   arg3 = (int)jarg3;
89867   {
89868     try {
89869       try {
89870         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89871       }
89872       catch(std::out_of_range &_e) {
89873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89874         return ;
89875       }
89876       catch(std::invalid_argument &_e) {
89877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89878         return ;
89879       }
89880
89881     } catch (std::out_of_range& e) {
89882       {
89883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89884       };
89885     } catch (std::exception& e) {
89886       {
89887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89888       };
89889     } catch (Dali::DaliException e) {
89890       {
89891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89892       };
89893     } catch (...) {
89894       {
89895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89896       };
89897     }
89898   }
89899
89900 }
89901
89902
89903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89904   void * jresult ;
89905   Dali::Actor *arg1 = 0 ;
89906   int arg2 ;
89907   std::vector< Dali::Actor > *result = 0 ;
89908
89909   arg1 = (Dali::Actor *)jarg1;
89910   if (!arg1) {
89911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89912     return 0;
89913   }
89914   arg2 = (int)jarg2;
89915   {
89916     try {
89917       try {
89918         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89919       }
89920       catch(std::out_of_range &_e) {
89921         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89922         return 0;
89923       }
89924
89925     } catch (std::out_of_range& e) {
89926       {
89927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89928       };
89929     } catch (std::exception& e) {
89930       {
89931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89932       };
89933     } catch (Dali::DaliException e) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89936       };
89937     } catch (...) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89940       };
89941     }
89942   }
89943
89944   jresult = (void *)result;
89945   return jresult;
89946 }
89947
89948
89949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89950   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89951
89952   arg1 = (std::vector< Dali::Actor > *)jarg1;
89953   {
89954     try {
89955       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89956     } catch (std::out_of_range& e) {
89957       {
89958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89959       };
89960     } catch (std::exception& e) {
89961       {
89962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89963       };
89964     } catch (Dali::DaliException e) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89967       };
89968     } catch (...) {
89969       {
89970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89971       };
89972     }
89973   }
89974
89975 }
89976
89977
89978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89979   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89980   int arg2 ;
89981   int arg3 ;
89982
89983   arg1 = (std::vector< Dali::Actor > *)jarg1;
89984   arg2 = (int)jarg2;
89985   arg3 = (int)jarg3;
89986   {
89987     try {
89988       try {
89989         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89990       }
89991       catch(std::out_of_range &_e) {
89992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89993         return ;
89994       }
89995       catch(std::invalid_argument &_e) {
89996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89997         return ;
89998       }
89999
90000     } catch (std::out_of_range& e) {
90001       {
90002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90003       };
90004     } catch (std::exception& e) {
90005       {
90006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (Dali::DaliException e) {
90009       {
90010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018
90019 }
90020
90021
90022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90023   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90024   int arg2 ;
90025   std::vector< Dali::Actor > *arg3 = 0 ;
90026
90027   arg1 = (std::vector< Dali::Actor > *)jarg1;
90028   arg2 = (int)jarg2;
90029   arg3 = (std::vector< Dali::Actor > *)jarg3;
90030   if (!arg3) {
90031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90032     return ;
90033   }
90034   {
90035     try {
90036       try {
90037         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90038       }
90039       catch(std::out_of_range &_e) {
90040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90041         return ;
90042       }
90043
90044     } catch (std::out_of_range& e) {
90045       {
90046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90047       };
90048     } catch (std::exception& e) {
90049       {
90050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (Dali::DaliException e) {
90053       {
90054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90059       };
90060     }
90061   }
90062
90063 }
90064
90065
90066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90067   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90068
90069   arg1 = (std::vector< Dali::Actor > *)jarg1;
90070   {
90071     try {
90072       delete arg1;
90073     } catch (std::out_of_range& e) {
90074       {
90075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90076       };
90077     } catch (std::exception& e) {
90078       {
90079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90080       };
90081     } catch (Dali::DaliException e) {
90082       {
90083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90084       };
90085     } catch (...) {
90086       {
90087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90088       };
90089     }
90090   }
90091
90092 }
90093
90094
90095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90096   unsigned int jresult ;
90097   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90098   bool result;
90099
90100   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90101   {
90102     try {
90103       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90104     } catch (std::out_of_range& e) {
90105       {
90106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90107       };
90108     } catch (std::exception& e) {
90109       {
90110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90111       };
90112     } catch (Dali::DaliException e) {
90113       {
90114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90115       };
90116     } catch (...) {
90117       {
90118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90119       };
90120     }
90121   }
90122
90123   jresult = result;
90124   return jresult;
90125 }
90126
90127
90128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90129   unsigned long jresult ;
90130   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90131   std::size_t result;
90132
90133   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90134   {
90135     try {
90136       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
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 = (unsigned long)result;
90157   return jresult;
90158 }
90159
90160
90161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90162   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90163   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90164
90165   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90166   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90167   {
90168     try {
90169       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90170     } catch (std::out_of_range& e) {
90171       {
90172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90173       };
90174     } catch (std::exception& e) {
90175       {
90176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90177       };
90178     } catch (Dali::DaliException e) {
90179       {
90180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90181       };
90182     } catch (...) {
90183       {
90184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90185       };
90186     }
90187   }
90188
90189 }
90190
90191
90192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90193   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90194   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90195
90196   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90197   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90198   {
90199     try {
90200       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90201     } catch (std::out_of_range& e) {
90202       {
90203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90204       };
90205     } catch (std::exception& e) {
90206       {
90207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90208       };
90209     } catch (Dali::DaliException e) {
90210       {
90211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90212       };
90213     } catch (...) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90216       };
90217     }
90218   }
90219
90220 }
90221
90222
90223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90224   unsigned int jresult ;
90225   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90226   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90227   bool result;
90228
90229   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90230   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90231   if (!arg2) {
90232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90233     return 0;
90234   }
90235   {
90236     try {
90237       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90238     } catch (std::out_of_range& e) {
90239       {
90240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90241       };
90242     } catch (std::exception& e) {
90243       {
90244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90245       };
90246     } catch (Dali::DaliException e) {
90247       {
90248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90249       };
90250     } catch (...) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90253       };
90254     }
90255   }
90256
90257   jresult = result;
90258   return jresult;
90259 }
90260
90261
90262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90263   void * jresult ;
90264   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90265
90266   {
90267     try {
90268       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (Dali::DaliException e) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90284       };
90285     }
90286   }
90287
90288   jresult = (void *)result;
90289   return jresult;
90290 }
90291
90292
90293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90294   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90295
90296   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90297   {
90298     try {
90299       delete arg1;
90300     } catch (std::out_of_range& e) {
90301       {
90302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90303       };
90304     } catch (std::exception& e) {
90305       {
90306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90307       };
90308     } catch (Dali::DaliException e) {
90309       {
90310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90311       };
90312     } catch (...) {
90313       {
90314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90315       };
90316     }
90317   }
90318
90319 }
90320
90321
90322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90323   unsigned int jresult ;
90324   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90325   bool result;
90326
90327   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90328   {
90329     try {
90330       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);
90331     } catch (std::out_of_range& e) {
90332       {
90333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90334       };
90335     } catch (std::exception& e) {
90336       {
90337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90338       };
90339     } catch (Dali::DaliException e) {
90340       {
90341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90342       };
90343     } catch (...) {
90344       {
90345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90346       };
90347     }
90348   }
90349
90350   jresult = result;
90351   return jresult;
90352 }
90353
90354
90355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90356   unsigned long jresult ;
90357   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90358   std::size_t result;
90359
90360   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90361   {
90362     try {
90363       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);
90364     } catch (std::out_of_range& e) {
90365       {
90366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90367       };
90368     } catch (std::exception& e) {
90369       {
90370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90371       };
90372     } catch (Dali::DaliException e) {
90373       {
90374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90375       };
90376     } catch (...) {
90377       {
90378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90379       };
90380     }
90381   }
90382
90383   jresult = (unsigned long)result;
90384   return jresult;
90385 }
90386
90387
90388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90389   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90390   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90391
90392   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90393   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90394   {
90395     try {
90396       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90397     } catch (std::out_of_range& e) {
90398       {
90399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90400       };
90401     } catch (std::exception& e) {
90402       {
90403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90404       };
90405     } catch (Dali::DaliException e) {
90406       {
90407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90408       };
90409     } catch (...) {
90410       {
90411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90412       };
90413     }
90414   }
90415
90416 }
90417
90418
90419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90420   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90421   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90422
90423   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90424   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90425   {
90426     try {
90427       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90428     } catch (std::out_of_range& e) {
90429       {
90430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90431       };
90432     } catch (std::exception& e) {
90433       {
90434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90435       };
90436     } catch (Dali::DaliException e) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90439       };
90440     } catch (...) {
90441       {
90442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90443       };
90444     }
90445   }
90446
90447 }
90448
90449
90450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90451   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90452   Dali::Actor arg2 ;
90453   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90454   Dali::Actor *argp2 ;
90455
90456   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90457   argp2 = (Dali::Actor *)jarg2;
90458   if (!argp2) {
90459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90460     return ;
90461   }
90462   arg2 = *argp2;
90463   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90464   {
90465     try {
90466       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90467     } catch (std::out_of_range& e) {
90468       {
90469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90470       };
90471     } catch (std::exception& e) {
90472       {
90473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90474       };
90475     } catch (Dali::DaliException e) {
90476       {
90477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90478       };
90479     } catch (...) {
90480       {
90481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90482       };
90483     }
90484   }
90485
90486 }
90487
90488
90489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90490   void * jresult ;
90491   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90492
90493   {
90494     try {
90495       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90496     } catch (std::out_of_range& e) {
90497       {
90498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90499       };
90500     } catch (std::exception& e) {
90501       {
90502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90503       };
90504     } catch (Dali::DaliException e) {
90505       {
90506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90507       };
90508     } catch (...) {
90509       {
90510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90511       };
90512     }
90513   }
90514
90515   jresult = (void *)result;
90516   return jresult;
90517 }
90518
90519
90520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90521   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90522
90523   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90524   {
90525     try {
90526       delete arg1;
90527     } catch (std::out_of_range& e) {
90528       {
90529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90530       };
90531     } catch (std::exception& e) {
90532       {
90533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90534       };
90535     } catch (Dali::DaliException e) {
90536       {
90537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90538       };
90539     } catch (...) {
90540       {
90541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90542       };
90543     }
90544   }
90545
90546 }
90547
90548
90549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90550   unsigned int jresult ;
90551   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90552   bool result;
90553
90554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90555   {
90556     try {
90557       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90558     } catch (std::out_of_range& e) {
90559       {
90560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90561       };
90562     } catch (std::exception& e) {
90563       {
90564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90565       };
90566     } catch (Dali::DaliException e) {
90567       {
90568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90569       };
90570     } catch (...) {
90571       {
90572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90573       };
90574     }
90575   }
90576
90577   jresult = result;
90578   return jresult;
90579 }
90580
90581
90582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90583   unsigned long jresult ;
90584   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90585   std::size_t result;
90586
90587   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90588   {
90589     try {
90590       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90591     } catch (std::out_of_range& e) {
90592       {
90593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90594       };
90595     } catch (std::exception& e) {
90596       {
90597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90598       };
90599     } catch (Dali::DaliException e) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90602       };
90603     } catch (...) {
90604       {
90605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90606       };
90607     }
90608   }
90609
90610   jresult = (unsigned long)result;
90611   return jresult;
90612 }
90613
90614
90615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90616   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90617   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90618
90619   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90620   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90621   {
90622     try {
90623       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90624     } catch (std::out_of_range& e) {
90625       {
90626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90627       };
90628     } catch (std::exception& e) {
90629       {
90630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90631       };
90632     } catch (Dali::DaliException e) {
90633       {
90634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90635       };
90636     } catch (...) {
90637       {
90638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90639       };
90640     }
90641   }
90642
90643 }
90644
90645
90646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90647   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90648   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90649
90650   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90651   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90652   {
90653     try {
90654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90655     } catch (std::out_of_range& e) {
90656       {
90657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90658       };
90659     } catch (std::exception& e) {
90660       {
90661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90662       };
90663     } catch (Dali::DaliException e) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90666       };
90667     } catch (...) {
90668       {
90669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90670       };
90671     }
90672   }
90673
90674 }
90675
90676
90677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90678   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90679   Dali::Actor arg2 ;
90680   Dali::Actor arg3 ;
90681   Dali::Actor *argp2 ;
90682   Dali::Actor *argp3 ;
90683
90684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90685   argp2 = (Dali::Actor *)jarg2;
90686   if (!argp2) {
90687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90688     return ;
90689   }
90690   arg2 = *argp2;
90691   argp3 = (Dali::Actor *)jarg3;
90692   if (!argp3) {
90693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90694     return ;
90695   }
90696   arg3 = *argp3;
90697   {
90698     try {
90699       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90700     } catch (std::out_of_range& e) {
90701       {
90702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90703       };
90704     } catch (std::exception& e) {
90705       {
90706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90707       };
90708     } catch (Dali::DaliException e) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90711       };
90712     } catch (...) {
90713       {
90714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90715       };
90716     }
90717   }
90718
90719 }
90720
90721
90722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90723   void * jresult ;
90724   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90725
90726   {
90727     try {
90728       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90729     } catch (std::out_of_range& e) {
90730       {
90731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90732       };
90733     } catch (std::exception& e) {
90734       {
90735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (Dali::DaliException e) {
90738       {
90739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90740       };
90741     } catch (...) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90744       };
90745     }
90746   }
90747
90748   jresult = (void *)result;
90749   return jresult;
90750 }
90751
90752
90753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90754   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90755
90756   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90757   {
90758     try {
90759       delete arg1;
90760     } catch (std::out_of_range& e) {
90761       {
90762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90763       };
90764     } catch (std::exception& e) {
90765       {
90766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90767       };
90768     } catch (Dali::DaliException e) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90771       };
90772     } catch (...) {
90773       {
90774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90775       };
90776     }
90777   }
90778
90779 }
90780
90781
90782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90783   unsigned int jresult ;
90784   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90785   bool result;
90786
90787   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90788   {
90789     try {
90790       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90791     } catch (std::out_of_range& e) {
90792       {
90793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90794       };
90795     } catch (std::exception& e) {
90796       {
90797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90798       };
90799     } catch (Dali::DaliException e) {
90800       {
90801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90802       };
90803     } catch (...) {
90804       {
90805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90806       };
90807     }
90808   }
90809
90810   jresult = result;
90811   return jresult;
90812 }
90813
90814
90815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90816   unsigned long jresult ;
90817   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90818   std::size_t result;
90819
90820   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90821   {
90822     try {
90823       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90824     } catch (std::out_of_range& e) {
90825       {
90826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90827       };
90828     } catch (std::exception& e) {
90829       {
90830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90831       };
90832     } catch (Dali::DaliException e) {
90833       {
90834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90835       };
90836     } catch (...) {
90837       {
90838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90839       };
90840     }
90841   }
90842
90843   jresult = (unsigned long)result;
90844   return jresult;
90845 }
90846
90847
90848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90849   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90850   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90851
90852   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90853   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90854   {
90855     try {
90856       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90857     } catch (std::out_of_range& e) {
90858       {
90859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90860       };
90861     } catch (std::exception& e) {
90862       {
90863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90864       };
90865     } catch (Dali::DaliException e) {
90866       {
90867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90868       };
90869     } catch (...) {
90870       {
90871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90872       };
90873     }
90874   }
90875
90876 }
90877
90878
90879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90880   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90881   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90882
90883   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90884   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90885   {
90886     try {
90887       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90888     } catch (std::out_of_range& e) {
90889       {
90890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90891       };
90892     } catch (std::exception& e) {
90893       {
90894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90895       };
90896     } catch (Dali::DaliException e) {
90897       {
90898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90899       };
90900     } catch (...) {
90901       {
90902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90903       };
90904     }
90905   }
90906
90907 }
90908
90909
90910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90911   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90912   Dali::Actor arg2 ;
90913   bool arg3 ;
90914   Dali::Actor *argp2 ;
90915
90916   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90917   argp2 = (Dali::Actor *)jarg2;
90918   if (!argp2) {
90919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90920     return ;
90921   }
90922   arg2 = *argp2;
90923   arg3 = jarg3 ? true : false;
90924   {
90925     try {
90926       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90927     } catch (std::out_of_range& e) {
90928       {
90929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90930       };
90931     } catch (std::exception& e) {
90932       {
90933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90934       };
90935     } catch (Dali::DaliException e) {
90936       {
90937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90938       };
90939     } catch (...) {
90940       {
90941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90942       };
90943     }
90944   }
90945
90946 }
90947
90948
90949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90950   void * jresult ;
90951   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90952
90953   {
90954     try {
90955       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90956     } catch (std::out_of_range& e) {
90957       {
90958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90959       };
90960     } catch (std::exception& e) {
90961       {
90962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90963       };
90964     } catch (Dali::DaliException e) {
90965       {
90966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90967       };
90968     } catch (...) {
90969       {
90970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90971       };
90972     }
90973   }
90974
90975   jresult = (void *)result;
90976   return jresult;
90977 }
90978
90979
90980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90981   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90982
90983   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90984   {
90985     try {
90986       delete arg1;
90987     } catch (std::out_of_range& e) {
90988       {
90989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90990       };
90991     } catch (std::exception& e) {
90992       {
90993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90994       };
90995     } catch (Dali::DaliException e) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90998       };
90999     } catch (...) {
91000       {
91001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91002       };
91003     }
91004   }
91005
91006 }
91007
91008
91009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91010   unsigned int jresult ;
91011   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91012   bool result;
91013
91014   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91015   {
91016     try {
91017       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);
91018     } catch (std::out_of_range& e) {
91019       {
91020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91021       };
91022     } catch (std::exception& e) {
91023       {
91024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91025       };
91026     } catch (Dali::DaliException e) {
91027       {
91028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91029       };
91030     } catch (...) {
91031       {
91032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91033       };
91034     }
91035   }
91036
91037   jresult = result;
91038   return jresult;
91039 }
91040
91041
91042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91043   unsigned long jresult ;
91044   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91045   std::size_t result;
91046
91047   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91048   {
91049     try {
91050       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);
91051     } catch (std::out_of_range& e) {
91052       {
91053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91054       };
91055     } catch (std::exception& e) {
91056       {
91057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91058       };
91059     } catch (Dali::DaliException e) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91062       };
91063     } catch (...) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91066       };
91067     }
91068   }
91069
91070   jresult = (unsigned long)result;
91071   return jresult;
91072 }
91073
91074
91075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91076   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91077   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91078
91079   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91080   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91081   {
91082     try {
91083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91084     } catch (std::out_of_range& e) {
91085       {
91086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91087       };
91088     } catch (std::exception& e) {
91089       {
91090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91091       };
91092     } catch (Dali::DaliException e) {
91093       {
91094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91095       };
91096     } catch (...) {
91097       {
91098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91099       };
91100     }
91101   }
91102
91103 }
91104
91105
91106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91107   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91108   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91109
91110   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91111   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91112   {
91113     try {
91114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91115     } catch (std::out_of_range& e) {
91116       {
91117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91118       };
91119     } catch (std::exception& e) {
91120       {
91121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91122       };
91123     } catch (Dali::DaliException e) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91126       };
91127     } catch (...) {
91128       {
91129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91130       };
91131     }
91132   }
91133
91134 }
91135
91136
91137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91138   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91139   Dali::Toolkit::StyleManager arg2 ;
91140   Dali::StyleChange::Type arg3 ;
91141   Dali::Toolkit::StyleManager *argp2 ;
91142
91143   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91144   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91145   if (!argp2) {
91146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91147     return ;
91148   }
91149   arg2 = *argp2;
91150   arg3 = (Dali::StyleChange::Type)jarg3;
91151   {
91152     try {
91153       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91154     } catch (std::out_of_range& e) {
91155       {
91156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91157       };
91158     } catch (std::exception& e) {
91159       {
91160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91161       };
91162     } catch (Dali::DaliException e) {
91163       {
91164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91165       };
91166     } catch (...) {
91167       {
91168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91169       };
91170     }
91171   }
91172
91173 }
91174
91175
91176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91177   void * jresult ;
91178   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91179
91180   {
91181     try {
91182       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91183     } catch (std::out_of_range& e) {
91184       {
91185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91186       };
91187     } catch (std::exception& e) {
91188       {
91189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91190       };
91191     } catch (Dali::DaliException e) {
91192       {
91193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91194       };
91195     } catch (...) {
91196       {
91197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91198       };
91199     }
91200   }
91201
91202   jresult = (void *)result;
91203   return jresult;
91204 }
91205
91206
91207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91208   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91209
91210   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91211   {
91212     try {
91213       delete arg1;
91214     } catch (std::out_of_range& e) {
91215       {
91216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (std::exception& e) {
91219       {
91220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91221       };
91222     } catch (Dali::DaliException e) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91229       };
91230     }
91231   }
91232
91233 }
91234
91235
91236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91237   unsigned int jresult ;
91238   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91239   bool result;
91240
91241   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91242   {
91243     try {
91244       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91245     } catch (std::out_of_range& e) {
91246       {
91247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91248       };
91249     } catch (std::exception& e) {
91250       {
91251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91252       };
91253     } catch (Dali::DaliException e) {
91254       {
91255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91256       };
91257     } catch (...) {
91258       {
91259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91260       };
91261     }
91262   }
91263
91264   jresult = result;
91265   return jresult;
91266 }
91267
91268
91269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91270   unsigned long jresult ;
91271   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91272   std::size_t result;
91273
91274   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91275   {
91276     try {
91277       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91278     } catch (std::out_of_range& e) {
91279       {
91280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91281       };
91282     } catch (std::exception& e) {
91283       {
91284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91285       };
91286     } catch (Dali::DaliException e) {
91287       {
91288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91289       };
91290     } catch (...) {
91291       {
91292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91293       };
91294     }
91295   }
91296
91297   jresult = (unsigned long)result;
91298   return jresult;
91299 }
91300
91301
91302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91303   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91304   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91305
91306   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91307   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91308   {
91309     try {
91310       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91311     } catch (std::out_of_range& e) {
91312       {
91313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91314       };
91315     } catch (std::exception& e) {
91316       {
91317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91318       };
91319     } catch (Dali::DaliException e) {
91320       {
91321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91322       };
91323     } catch (...) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91326       };
91327     }
91328   }
91329
91330 }
91331
91332
91333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91334   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91335   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91336
91337   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91338   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91339   {
91340     try {
91341       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91342     } catch (std::out_of_range& e) {
91343       {
91344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91345       };
91346     } catch (std::exception& e) {
91347       {
91348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91349       };
91350     } catch (Dali::DaliException e) {
91351       {
91352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91353       };
91354     } catch (...) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91357       };
91358     }
91359   }
91360
91361 }
91362
91363
91364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91365   unsigned int jresult ;
91366   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91367   Dali::Toolkit::Button arg2 ;
91368   Dali::Toolkit::Button *argp2 ;
91369   bool result;
91370
91371   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91372   argp2 = (Dali::Toolkit::Button *)jarg2;
91373   if (!argp2) {
91374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91375     return 0;
91376   }
91377   arg2 = *argp2;
91378   {
91379     try {
91380       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91381     } catch (std::out_of_range& e) {
91382       {
91383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91384       };
91385     } catch (std::exception& e) {
91386       {
91387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91388       };
91389     } catch (Dali::DaliException e) {
91390       {
91391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91392       };
91393     } catch (...) {
91394       {
91395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91396       };
91397     }
91398   }
91399
91400   jresult = result;
91401   return jresult;
91402 }
91403
91404
91405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91406   void * jresult ;
91407   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91408
91409   {
91410     try {
91411       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91427       };
91428     }
91429   }
91430
91431   jresult = (void *)result;
91432   return jresult;
91433 }
91434
91435
91436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91437   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91438
91439   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91440   {
91441     try {
91442       delete arg1;
91443     } catch (std::out_of_range& e) {
91444       {
91445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91446       };
91447     } catch (std::exception& e) {
91448       {
91449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91450       };
91451     } catch (Dali::DaliException e) {
91452       {
91453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91454       };
91455     } catch (...) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91458       };
91459     }
91460   }
91461
91462 }
91463
91464
91465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91466   unsigned int jresult ;
91467   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91468   bool result;
91469
91470   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91471   {
91472     try {
91473       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91474     } catch (std::out_of_range& e) {
91475       {
91476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91477       };
91478     } catch (std::exception& e) {
91479       {
91480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91481       };
91482     } catch (Dali::DaliException e) {
91483       {
91484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91485       };
91486     } catch (...) {
91487       {
91488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91489       };
91490     }
91491   }
91492
91493   jresult = result;
91494   return jresult;
91495 }
91496
91497
91498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91499   unsigned long jresult ;
91500   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91501   std::size_t result;
91502
91503   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91504   {
91505     try {
91506       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91507     } catch (std::out_of_range& e) {
91508       {
91509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91510       };
91511     } catch (std::exception& e) {
91512       {
91513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91514       };
91515     } catch (Dali::DaliException e) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91518       };
91519     } catch (...) {
91520       {
91521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91522       };
91523     }
91524   }
91525
91526   jresult = (unsigned long)result;
91527   return jresult;
91528 }
91529
91530
91531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91532   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91533   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91534
91535   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91536   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91537   {
91538     try {
91539       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91540     } catch (std::out_of_range& e) {
91541       {
91542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91543       };
91544     } catch (std::exception& e) {
91545       {
91546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (Dali::DaliException e) {
91549       {
91550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91551       };
91552     } catch (...) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91555       };
91556     }
91557   }
91558
91559 }
91560
91561
91562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91563   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91564   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91565
91566   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91567   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91568   {
91569     try {
91570       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91571     } catch (std::out_of_range& e) {
91572       {
91573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91574       };
91575     } catch (std::exception& e) {
91576       {
91577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91578       };
91579     } catch (Dali::DaliException e) {
91580       {
91581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91582       };
91583     } catch (...) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91586       };
91587     }
91588   }
91589
91590 }
91591
91592
91593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91594   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91595   Dali::Toolkit::GaussianBlurView arg2 ;
91596   Dali::Toolkit::GaussianBlurView *argp2 ;
91597
91598   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91599   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91600   if (!argp2) {
91601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91602     return ;
91603   }
91604   arg2 = *argp2;
91605   {
91606     try {
91607       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91615       };
91616     } catch (Dali::DaliException e) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91623       };
91624     }
91625   }
91626
91627 }
91628
91629
91630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91631   void * jresult ;
91632   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91633
91634   {
91635     try {
91636       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91637     } catch (std::out_of_range& e) {
91638       {
91639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91640       };
91641     } catch (std::exception& e) {
91642       {
91643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91644       };
91645     } catch (Dali::DaliException e) {
91646       {
91647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91648       };
91649     } catch (...) {
91650       {
91651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91652       };
91653     }
91654   }
91655
91656   jresult = (void *)result;
91657   return jresult;
91658 }
91659
91660
91661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91662   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91663
91664   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91665   {
91666     try {
91667       delete arg1;
91668     } catch (std::out_of_range& e) {
91669       {
91670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91671       };
91672     } catch (std::exception& e) {
91673       {
91674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91675       };
91676     } catch (Dali::DaliException e) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91679       };
91680     } catch (...) {
91681       {
91682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91683       };
91684     }
91685   }
91686
91687 }
91688
91689
91690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91691   unsigned int jresult ;
91692   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91693   bool result;
91694
91695   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91696   {
91697     try {
91698       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);
91699     } catch (std::out_of_range& e) {
91700       {
91701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91702       };
91703     } catch (std::exception& e) {
91704       {
91705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91706       };
91707     } catch (Dali::DaliException e) {
91708       {
91709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91710       };
91711     } catch (...) {
91712       {
91713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91714       };
91715     }
91716   }
91717
91718   jresult = result;
91719   return jresult;
91720 }
91721
91722
91723 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91724   unsigned long jresult ;
91725   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91726   std::size_t result;
91727
91728   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91729   {
91730     try {
91731       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);
91732     } catch (std::out_of_range& e) {
91733       {
91734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91735       };
91736     } catch (std::exception& e) {
91737       {
91738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91739       };
91740     } catch (Dali::DaliException e) {
91741       {
91742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91743       };
91744     } catch (...) {
91745       {
91746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91747       };
91748     }
91749   }
91750
91751   jresult = (unsigned long)result;
91752   return jresult;
91753 }
91754
91755
91756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91757   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91758   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91759
91760   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91761   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91762   {
91763     try {
91764       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91765     } catch (std::out_of_range& e) {
91766       {
91767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91768       };
91769     } catch (std::exception& e) {
91770       {
91771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (Dali::DaliException e) {
91774       {
91775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91776       };
91777     } catch (...) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91780       };
91781     }
91782   }
91783
91784 }
91785
91786
91787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91788   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91789   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91790
91791   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91792   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91793   {
91794     try {
91795       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91796     } catch (std::out_of_range& e) {
91797       {
91798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91799       };
91800     } catch (std::exception& e) {
91801       {
91802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91803       };
91804     } catch (Dali::DaliException e) {
91805       {
91806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91807       };
91808     } catch (...) {
91809       {
91810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91811       };
91812     }
91813   }
91814
91815 }
91816
91817
91818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91819   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91820   Dali::Toolkit::PageTurnView arg2 ;
91821   unsigned int arg3 ;
91822   bool arg4 ;
91823   Dali::Toolkit::PageTurnView *argp2 ;
91824
91825   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91826   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91827   if (!argp2) {
91828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91829     return ;
91830   }
91831   arg2 = *argp2;
91832   arg3 = (unsigned int)jarg3;
91833   arg4 = jarg4 ? true : false;
91834   {
91835     try {
91836       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91837     } catch (std::out_of_range& e) {
91838       {
91839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91840       };
91841     } catch (std::exception& e) {
91842       {
91843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91844       };
91845     } catch (Dali::DaliException e) {
91846       {
91847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91848       };
91849     } catch (...) {
91850       {
91851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91852       };
91853     }
91854   }
91855
91856 }
91857
91858
91859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91860   void * jresult ;
91861   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91862
91863   {
91864     try {
91865       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (Dali::DaliException e) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91877       };
91878     } catch (...) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91881       };
91882     }
91883   }
91884
91885   jresult = (void *)result;
91886   return jresult;
91887 }
91888
91889
91890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91891   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91892
91893   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91894   {
91895     try {
91896       delete arg1;
91897     } catch (std::out_of_range& e) {
91898       {
91899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91900       };
91901     } catch (std::exception& e) {
91902       {
91903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91904       };
91905     } catch (Dali::DaliException e) {
91906       {
91907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91908       };
91909     } catch (...) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91912       };
91913     }
91914   }
91915
91916 }
91917
91918
91919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91920   unsigned int jresult ;
91921   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91922   bool result;
91923
91924   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91925   {
91926     try {
91927       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91928     } catch (std::out_of_range& e) {
91929       {
91930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91931       };
91932     } catch (std::exception& e) {
91933       {
91934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91935       };
91936     } catch (Dali::DaliException e) {
91937       {
91938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91939       };
91940     } catch (...) {
91941       {
91942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91943       };
91944     }
91945   }
91946
91947   jresult = result;
91948   return jresult;
91949 }
91950
91951
91952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91953   unsigned long jresult ;
91954   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91955   std::size_t result;
91956
91957   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91958   {
91959     try {
91960       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91961     } catch (std::out_of_range& e) {
91962       {
91963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91964       };
91965     } catch (std::exception& e) {
91966       {
91967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91968       };
91969     } catch (Dali::DaliException e) {
91970       {
91971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91972       };
91973     } catch (...) {
91974       {
91975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91976       };
91977     }
91978   }
91979
91980   jresult = (unsigned long)result;
91981   return jresult;
91982 }
91983
91984
91985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91986   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91987   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91988
91989   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91990   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91991   {
91992     try {
91993       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91994     } catch (std::out_of_range& e) {
91995       {
91996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91997       };
91998     } catch (std::exception& e) {
91999       {
92000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92001       };
92002     } catch (Dali::DaliException e) {
92003       {
92004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92005       };
92006     } catch (...) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92009       };
92010     }
92011   }
92012
92013 }
92014
92015
92016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92017   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92018   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92019
92020   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92021   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92022   {
92023     try {
92024       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92025     } catch (std::out_of_range& e) {
92026       {
92027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92028       };
92029     } catch (std::exception& e) {
92030       {
92031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92032       };
92033     } catch (Dali::DaliException e) {
92034       {
92035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92036       };
92037     } catch (...) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92040       };
92041     }
92042   }
92043
92044 }
92045
92046
92047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92048   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92049   Dali::Toolkit::PageTurnView arg2 ;
92050   Dali::Toolkit::PageTurnView *argp2 ;
92051
92052   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92053   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92054   if (!argp2) {
92055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92056     return ;
92057   }
92058   arg2 = *argp2;
92059   {
92060     try {
92061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92062     } catch (std::out_of_range& e) {
92063       {
92064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92065       };
92066     } catch (std::exception& e) {
92067       {
92068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92069       };
92070     } catch (Dali::DaliException e) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92073       };
92074     } catch (...) {
92075       {
92076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92077       };
92078     }
92079   }
92080
92081 }
92082
92083
92084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92085   void * jresult ;
92086   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92087
92088   {
92089     try {
92090       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92091     } catch (std::out_of_range& e) {
92092       {
92093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92094       };
92095     } catch (std::exception& e) {
92096       {
92097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92098       };
92099     } catch (Dali::DaliException e) {
92100       {
92101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92102       };
92103     } catch (...) {
92104       {
92105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92106       };
92107     }
92108   }
92109
92110   jresult = (void *)result;
92111   return jresult;
92112 }
92113
92114
92115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92116   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92117
92118   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92119   {
92120     try {
92121       delete arg1;
92122     } catch (std::out_of_range& e) {
92123       {
92124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92125       };
92126     } catch (std::exception& e) {
92127       {
92128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92129       };
92130     } catch (Dali::DaliException e) {
92131       {
92132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92133       };
92134     } catch (...) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92137       };
92138     }
92139   }
92140
92141 }
92142
92143
92144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92145   unsigned int jresult ;
92146   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92147   bool result;
92148
92149   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92150   {
92151     try {
92152       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);
92153     } catch (std::out_of_range& e) {
92154       {
92155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92156       };
92157     } catch (std::exception& e) {
92158       {
92159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92160       };
92161     } catch (Dali::DaliException e) {
92162       {
92163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92164       };
92165     } catch (...) {
92166       {
92167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92168       };
92169     }
92170   }
92171
92172   jresult = result;
92173   return jresult;
92174 }
92175
92176
92177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92178   unsigned long jresult ;
92179   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92180   std::size_t result;
92181
92182   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92183   {
92184     try {
92185       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);
92186     } catch (std::out_of_range& e) {
92187       {
92188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92189       };
92190     } catch (std::exception& e) {
92191       {
92192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92193       };
92194     } catch (Dali::DaliException e) {
92195       {
92196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92197       };
92198     } catch (...) {
92199       {
92200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92201       };
92202     }
92203   }
92204
92205   jresult = (unsigned long)result;
92206   return jresult;
92207 }
92208
92209
92210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92211   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92212   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92213
92214   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92215   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92216   {
92217     try {
92218       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92219     } catch (std::out_of_range& e) {
92220       {
92221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92222       };
92223     } catch (std::exception& e) {
92224       {
92225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92226       };
92227     } catch (Dali::DaliException e) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92230       };
92231     } catch (...) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92234       };
92235     }
92236   }
92237
92238 }
92239
92240
92241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92242   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92243   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92244
92245   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92246   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92247   {
92248     try {
92249       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92250     } catch (std::out_of_range& e) {
92251       {
92252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92253       };
92254     } catch (std::exception& e) {
92255       {
92256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92257       };
92258     } catch (Dali::DaliException e) {
92259       {
92260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92261       };
92262     } catch (...) {
92263       {
92264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92265       };
92266     }
92267   }
92268
92269 }
92270
92271
92272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92273   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92274   Dali::Toolkit::ProgressBar arg2 ;
92275   float arg3 ;
92276   float arg4 ;
92277   Dali::Toolkit::ProgressBar *argp2 ;
92278
92279   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92280   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92281   if (!argp2) {
92282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92283     return ;
92284   }
92285   arg2 = *argp2;
92286   arg3 = (float)jarg3;
92287   arg4 = (float)jarg4;
92288   {
92289     try {
92290       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92291     } catch (std::out_of_range& e) {
92292       {
92293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92294       };
92295     } catch (std::exception& e) {
92296       {
92297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92298       };
92299     } catch (Dali::DaliException e) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92302       };
92303     } catch (...) {
92304       {
92305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92306       };
92307     }
92308   }
92309
92310 }
92311
92312
92313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92314   void * jresult ;
92315   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92316
92317   {
92318     try {
92319       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92320     } catch (std::out_of_range& e) {
92321       {
92322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92323       };
92324     } catch (std::exception& e) {
92325       {
92326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92327       };
92328     } catch (Dali::DaliException e) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92331       };
92332     } catch (...) {
92333       {
92334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92335       };
92336     }
92337   }
92338
92339   jresult = (void *)result;
92340   return jresult;
92341 }
92342
92343
92344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92345   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92346
92347   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92348   {
92349     try {
92350       delete arg1;
92351     } catch (std::out_of_range& e) {
92352       {
92353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92354       };
92355     } catch (std::exception& e) {
92356       {
92357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92358       };
92359     } catch (Dali::DaliException e) {
92360       {
92361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92362       };
92363     } catch (...) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92366       };
92367     }
92368   }
92369
92370 }
92371
92372
92373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92374   unsigned int jresult ;
92375   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92376   bool result;
92377
92378   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92379   {
92380     try {
92381       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);
92382     } catch (std::out_of_range& e) {
92383       {
92384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (std::exception& e) {
92387       {
92388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92389       };
92390     } catch (Dali::DaliException e) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92393       };
92394     } catch (...) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92397       };
92398     }
92399   }
92400
92401   jresult = result;
92402   return jresult;
92403 }
92404
92405
92406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92407   unsigned long jresult ;
92408   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92409   std::size_t result;
92410
92411   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92412   {
92413     try {
92414       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);
92415     } catch (std::out_of_range& e) {
92416       {
92417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92418       };
92419     } catch (std::exception& e) {
92420       {
92421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92422       };
92423     } catch (Dali::DaliException e) {
92424       {
92425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92426       };
92427     } catch (...) {
92428       {
92429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92430       };
92431     }
92432   }
92433
92434   jresult = (unsigned long)result;
92435   return jresult;
92436 }
92437
92438
92439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92440   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92441   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92442
92443   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92444   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92445   {
92446     try {
92447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92448     } catch (std::out_of_range& e) {
92449       {
92450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92451       };
92452     } catch (std::exception& e) {
92453       {
92454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92455       };
92456     } catch (Dali::DaliException e) {
92457       {
92458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92459       };
92460     } catch (...) {
92461       {
92462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92463       };
92464     }
92465   }
92466
92467 }
92468
92469
92470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92471   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92472   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92473
92474   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92475   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92476   {
92477     try {
92478       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92479     } catch (std::out_of_range& e) {
92480       {
92481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92482       };
92483     } catch (std::exception& e) {
92484       {
92485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92486       };
92487     } catch (Dali::DaliException e) {
92488       {
92489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92490       };
92491     } catch (...) {
92492       {
92493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92494       };
92495     }
92496   }
92497
92498 }
92499
92500
92501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92502   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92503   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92504
92505   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92506   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92507   if (!arg2) {
92508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92509     return ;
92510   }
92511   {
92512     try {
92513       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (Dali::DaliException e) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92529       };
92530     }
92531   }
92532
92533 }
92534
92535
92536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92537   void * jresult ;
92538   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92539
92540   {
92541     try {
92542       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92543     } catch (std::out_of_range& e) {
92544       {
92545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92546       };
92547     } catch (std::exception& e) {
92548       {
92549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92550       };
92551     } catch (Dali::DaliException e) {
92552       {
92553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92554       };
92555     } catch (...) {
92556       {
92557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92558       };
92559     }
92560   }
92561
92562   jresult = (void *)result;
92563   return jresult;
92564 }
92565
92566
92567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92568   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92569
92570   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92571   {
92572     try {
92573       delete arg1;
92574     } catch (std::out_of_range& e) {
92575       {
92576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92577       };
92578     } catch (std::exception& e) {
92579       {
92580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92581       };
92582     } catch (Dali::DaliException e) {
92583       {
92584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92585       };
92586     } catch (...) {
92587       {
92588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92589       };
92590     }
92591   }
92592
92593 }
92594
92595
92596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92597   unsigned int jresult ;
92598   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92599   bool result;
92600
92601   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92602   {
92603     try {
92604       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92605     } catch (std::out_of_range& e) {
92606       {
92607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92608       };
92609     } catch (std::exception& e) {
92610       {
92611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92612       };
92613     } catch (Dali::DaliException e) {
92614       {
92615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92616       };
92617     } catch (...) {
92618       {
92619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92620       };
92621     }
92622   }
92623
92624   jresult = result;
92625   return jresult;
92626 }
92627
92628
92629 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92630   unsigned long jresult ;
92631   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92632   std::size_t result;
92633
92634   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92635   {
92636     try {
92637       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92638     } catch (std::out_of_range& e) {
92639       {
92640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92641       };
92642     } catch (std::exception& e) {
92643       {
92644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92645       };
92646     } catch (Dali::DaliException e) {
92647       {
92648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92649       };
92650     } catch (...) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92653       };
92654     }
92655   }
92656
92657   jresult = (unsigned long)result;
92658   return jresult;
92659 }
92660
92661
92662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92663   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92664   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92665
92666   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92667   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92668   {
92669     try {
92670       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92671     } catch (std::out_of_range& e) {
92672       {
92673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92674       };
92675     } catch (std::exception& e) {
92676       {
92677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92678       };
92679     } catch (Dali::DaliException e) {
92680       {
92681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92682       };
92683     } catch (...) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92686       };
92687     }
92688   }
92689
92690 }
92691
92692
92693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92694   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92695   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92696
92697   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92698   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92699   {
92700     try {
92701       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92702     } catch (std::out_of_range& e) {
92703       {
92704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92705       };
92706     } catch (std::exception& e) {
92707       {
92708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92709       };
92710     } catch (Dali::DaliException e) {
92711       {
92712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92713       };
92714     } catch (...) {
92715       {
92716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92717       };
92718     }
92719   }
92720
92721 }
92722
92723
92724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92725   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92726   Dali::Vector2 *arg2 = 0 ;
92727
92728   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92729   arg2 = (Dali::Vector2 *)jarg2;
92730   if (!arg2) {
92731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92732     return ;
92733   }
92734   {
92735     try {
92736       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92737     } catch (std::out_of_range& e) {
92738       {
92739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92740       };
92741     } catch (std::exception& e) {
92742       {
92743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92744       };
92745     } catch (Dali::DaliException e) {
92746       {
92747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92748       };
92749     } catch (...) {
92750       {
92751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92752       };
92753     }
92754   }
92755
92756 }
92757
92758
92759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92760   void * jresult ;
92761   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92762
92763   {
92764     try {
92765       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92766     } catch (std::out_of_range& e) {
92767       {
92768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92769       };
92770     } catch (std::exception& e) {
92771       {
92772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92773       };
92774     } catch (Dali::DaliException e) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92777       };
92778     } catch (...) {
92779       {
92780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92781       };
92782     }
92783   }
92784
92785   jresult = (void *)result;
92786   return jresult;
92787 }
92788
92789
92790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92791   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92792
92793   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92794   {
92795     try {
92796       delete arg1;
92797     } catch (std::out_of_range& e) {
92798       {
92799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92800       };
92801     } catch (std::exception& e) {
92802       {
92803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92804       };
92805     } catch (Dali::DaliException e) {
92806       {
92807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92808       };
92809     } catch (...) {
92810       {
92811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92812       };
92813     }
92814   }
92815
92816 }
92817
92818
92819
92820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92821   unsigned int jresult ;
92822   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92823   bool result;
92824
92825   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92826   {
92827     try {
92828       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);
92829     } catch (std::out_of_range& e) {
92830       {
92831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92832       };
92833     } catch (std::exception& e) {
92834       {
92835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92836       };
92837     } catch (Dali::DaliException e) {
92838       {
92839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92840       };
92841     } catch (...) {
92842       {
92843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92844       };
92845     }
92846   }
92847
92848   jresult = result;
92849   return jresult;
92850 }
92851
92852
92853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92854   unsigned long jresult ;
92855   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92856   std::size_t result;
92857
92858   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92859   {
92860     try {
92861       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);
92862     } catch (std::out_of_range& e) {
92863       {
92864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92865       };
92866     } catch (std::exception& e) {
92867       {
92868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92869       };
92870     } catch (Dali::DaliException e) {
92871       {
92872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92873       };
92874     } catch (...) {
92875       {
92876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92877       };
92878     }
92879   }
92880
92881   jresult = (unsigned long)result;
92882   return jresult;
92883 }
92884
92885
92886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92887   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92888   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92889
92890   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92891   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92892   {
92893     try {
92894       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92895     } catch (std::out_of_range& e) {
92896       {
92897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92898       };
92899     } catch (std::exception& e) {
92900       {
92901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92902       };
92903     } catch (Dali::DaliException e) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92906       };
92907     } catch (...) {
92908       {
92909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92910       };
92911     }
92912   }
92913
92914 }
92915
92916
92917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92918   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92919   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92920
92921   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92922   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92923   {
92924     try {
92925       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92926     } catch (std::out_of_range& e) {
92927       {
92928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92929       };
92930     } catch (std::exception& e) {
92931       {
92932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92933       };
92934     } catch (Dali::DaliException e) {
92935       {
92936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92937       };
92938     } catch (...) {
92939       {
92940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92941       };
92942     }
92943   }
92944
92945 }
92946
92947
92948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92949   unsigned int jresult ;
92950   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92951   Dali::Toolkit::Control arg2 ;
92952   Dali::KeyEvent *arg3 = 0 ;
92953   Dali::Toolkit::Control *argp2 ;
92954   bool result;
92955
92956   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92957   argp2 = (Dali::Toolkit::Control *)jarg2;
92958   if (!argp2) {
92959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92960     return 0;
92961   }
92962   arg2 = *argp2;
92963   arg3 = (Dali::KeyEvent *)jarg3;
92964   if (!arg3) {
92965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92966     return 0;
92967   }
92968   {
92969     try {
92970       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);
92971     } catch (std::out_of_range& e) {
92972       {
92973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92974       };
92975     } catch (std::exception& e) {
92976       {
92977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92978       };
92979     } catch (Dali::DaliException e) {
92980       {
92981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92982       };
92983     } catch (...) {
92984       {
92985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92986       };
92987     }
92988   }
92989
92990   jresult = result;
92991   return jresult;
92992 }
92993
92994
92995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92996   void * jresult ;
92997   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92998
92999   {
93000     try {
93001       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93002     } catch (std::out_of_range& e) {
93003       {
93004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93005       };
93006     } catch (std::exception& e) {
93007       {
93008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93009       };
93010     } catch (Dali::DaliException e) {
93011       {
93012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93013       };
93014     } catch (...) {
93015       {
93016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93017       };
93018     }
93019   }
93020
93021   jresult = (void *)result;
93022   return jresult;
93023 }
93024
93025
93026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93027   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93028
93029   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93030   {
93031     try {
93032       delete arg1;
93033     } catch (std::out_of_range& e) {
93034       {
93035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93036       };
93037     } catch (std::exception& e) {
93038       {
93039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93040       };
93041     } catch (Dali::DaliException e) {
93042       {
93043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93044       };
93045     } catch (...) {
93046       {
93047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93048       };
93049     }
93050   }
93051
93052 }
93053
93054
93055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93056   unsigned int jresult ;
93057   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93058   bool result;
93059
93060   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93061   {
93062     try {
93063       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93064     } catch (std::out_of_range& e) {
93065       {
93066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93067       };
93068     } catch (std::exception& e) {
93069       {
93070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93071       };
93072     } catch (Dali::DaliException e) {
93073       {
93074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93075       };
93076     } catch (...) {
93077       {
93078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93079       };
93080     }
93081   }
93082
93083   jresult = result;
93084   return jresult;
93085 }
93086
93087
93088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93089   unsigned long jresult ;
93090   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93091   std::size_t result;
93092
93093   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93094   {
93095     try {
93096       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93097     } catch (std::out_of_range& e) {
93098       {
93099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93100       };
93101     } catch (std::exception& e) {
93102       {
93103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93104       };
93105     } catch (Dali::DaliException e) {
93106       {
93107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93108       };
93109     } catch (...) {
93110       {
93111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93112       };
93113     }
93114   }
93115
93116   jresult = (unsigned long)result;
93117   return jresult;
93118 }
93119
93120
93121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93122   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93123   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93124
93125   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93126   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93127   {
93128     try {
93129       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93130     } catch (std::out_of_range& e) {
93131       {
93132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93133       };
93134     } catch (std::exception& e) {
93135       {
93136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93137       };
93138     } catch (Dali::DaliException e) {
93139       {
93140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93141       };
93142     } catch (...) {
93143       {
93144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93145       };
93146     }
93147   }
93148
93149 }
93150
93151
93152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93153   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93154   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93155
93156   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93157   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93158   {
93159     try {
93160       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93161     } catch (std::out_of_range& e) {
93162       {
93163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93164       };
93165     } catch (std::exception& e) {
93166       {
93167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93168       };
93169     } catch (Dali::DaliException e) {
93170       {
93171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93172       };
93173     } catch (...) {
93174       {
93175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93176       };
93177     }
93178   }
93179
93180 }
93181
93182
93183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93184   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93185   Dali::Toolkit::Control arg2 ;
93186   Dali::Toolkit::Control *argp2 ;
93187
93188   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93189   argp2 = (Dali::Toolkit::Control *)jarg2;
93190   if (!argp2) {
93191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93192     return ;
93193   }
93194   arg2 = *argp2;
93195   {
93196     try {
93197       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93198     } catch (std::out_of_range& e) {
93199       {
93200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93201       };
93202     } catch (std::exception& e) {
93203       {
93204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93205       };
93206     } catch (Dali::DaliException e) {
93207       {
93208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93209       };
93210     } catch (...) {
93211       {
93212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93213       };
93214     }
93215   }
93216
93217 }
93218
93219
93220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93221   void * jresult ;
93222   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93223
93224   {
93225     try {
93226       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93227     } catch (std::out_of_range& e) {
93228       {
93229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93230       };
93231     } catch (std::exception& e) {
93232       {
93233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93234       };
93235     } catch (Dali::DaliException e) {
93236       {
93237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93238       };
93239     } catch (...) {
93240       {
93241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93242       };
93243     }
93244   }
93245
93246   jresult = (void *)result;
93247   return jresult;
93248 }
93249
93250
93251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93252   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93253
93254   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93255   {
93256     try {
93257       delete arg1;
93258     } catch (std::out_of_range& e) {
93259       {
93260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93261       };
93262     } catch (std::exception& e) {
93263       {
93264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93265       };
93266     } catch (Dali::DaliException e) {
93267       {
93268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93269       };
93270     } catch (...) {
93271       {
93272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93273       };
93274     }
93275   }
93276
93277 }
93278
93279
93280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93281   unsigned int jresult ;
93282   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93283   bool result;
93284
93285   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93286   {
93287     try {
93288       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93289     } catch (std::out_of_range& e) {
93290       {
93291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93292       };
93293     } catch (std::exception& e) {
93294       {
93295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93296       };
93297     } catch (Dali::DaliException e) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93300       };
93301     } catch (...) {
93302       {
93303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93304       };
93305     }
93306   }
93307
93308   jresult = result;
93309   return jresult;
93310 }
93311
93312
93313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93314   unsigned long jresult ;
93315   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93316   std::size_t result;
93317
93318   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93319   {
93320     try {
93321       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93322     } catch (std::out_of_range& e) {
93323       {
93324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93325       };
93326     } catch (std::exception& e) {
93327       {
93328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93329       };
93330     } catch (Dali::DaliException e) {
93331       {
93332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93333       };
93334     } catch (...) {
93335       {
93336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93337       };
93338     }
93339   }
93340
93341   jresult = (unsigned long)result;
93342   return jresult;
93343 }
93344
93345
93346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93347   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93348   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93349
93350   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93351   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93352   {
93353     try {
93354       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93355     } catch (std::out_of_range& e) {
93356       {
93357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93358       };
93359     } catch (std::exception& e) {
93360       {
93361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93362       };
93363     } catch (Dali::DaliException e) {
93364       {
93365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93366       };
93367     } catch (...) {
93368       {
93369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93370       };
93371     }
93372   }
93373
93374 }
93375
93376
93377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93378   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93379   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93380
93381   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93382   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93383   {
93384     try {
93385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93386     } catch (std::out_of_range& e) {
93387       {
93388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93389       };
93390     } catch (std::exception& e) {
93391       {
93392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93393       };
93394     } catch (Dali::DaliException e) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93397       };
93398     } catch (...) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93401       };
93402     }
93403   }
93404
93405 }
93406
93407
93408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93409   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93410   Dali::Toolkit::VideoView *arg2 = 0 ;
93411
93412   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93413   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93414   if (!arg2) {
93415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93416     return ;
93417   }
93418   {
93419     try {
93420       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93421     } catch (std::out_of_range& e) {
93422       {
93423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93424       };
93425     } catch (std::exception& e) {
93426       {
93427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93428       };
93429     } catch (Dali::DaliException e) {
93430       {
93431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93432       };
93433     } catch (...) {
93434       {
93435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93436       };
93437     }
93438   }
93439
93440 }
93441
93442
93443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93444   void * jresult ;
93445   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93446
93447   {
93448     try {
93449       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93450     } catch (std::out_of_range& e) {
93451       {
93452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93453       };
93454     } catch (std::exception& e) {
93455       {
93456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93457       };
93458     } catch (Dali::DaliException e) {
93459       {
93460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93461       };
93462     } catch (...) {
93463       {
93464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93465       };
93466     }
93467   }
93468
93469   jresult = (void *)result;
93470   return jresult;
93471 }
93472
93473
93474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93475   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93476
93477   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93478   {
93479     try {
93480       delete arg1;
93481     } catch (std::out_of_range& e) {
93482       {
93483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93484       };
93485     } catch (std::exception& e) {
93486       {
93487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93488       };
93489     } catch (Dali::DaliException e) {
93490       {
93491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93492       };
93493     } catch (...) {
93494       {
93495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93496       };
93497     }
93498   }
93499
93500 }
93501
93502
93503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93504   unsigned int jresult ;
93505   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93506   bool result;
93507
93508   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93509   {
93510     try {
93511       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93512     } catch (std::out_of_range& e) {
93513       {
93514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93515       };
93516     } catch (std::exception& e) {
93517       {
93518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93519       };
93520     } catch (Dali::DaliException e) {
93521       {
93522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93523       };
93524     } catch (...) {
93525       {
93526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93527       };
93528     }
93529   }
93530
93531   jresult = result;
93532   return jresult;
93533 }
93534
93535
93536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93537   unsigned long jresult ;
93538   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93539   std::size_t result;
93540
93541   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93542   {
93543     try {
93544       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93545     } catch (std::out_of_range& e) {
93546       {
93547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93548       };
93549     } catch (std::exception& e) {
93550       {
93551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93552       };
93553     } catch (Dali::DaliException e) {
93554       {
93555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93556       };
93557     } catch (...) {
93558       {
93559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93560       };
93561     }
93562   }
93563
93564   jresult = (unsigned long)result;
93565   return jresult;
93566 }
93567
93568
93569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93570   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93571   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93572
93573   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93574   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93575   {
93576     try {
93577       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93578     } catch (std::out_of_range& e) {
93579       {
93580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93581       };
93582     } catch (std::exception& e) {
93583       {
93584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93585       };
93586     } catch (Dali::DaliException e) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93589       };
93590     } catch (...) {
93591       {
93592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93593       };
93594     }
93595   }
93596
93597 }
93598
93599
93600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93601   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93602   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93603
93604   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93605   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93606   {
93607     try {
93608       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93609     } catch (std::out_of_range& e) {
93610       {
93611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93612       };
93613     } catch (std::exception& e) {
93614       {
93615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93616       };
93617     } catch (Dali::DaliException e) {
93618       {
93619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93620       };
93621     } catch (...) {
93622       {
93623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93624       };
93625     }
93626   }
93627
93628 }
93629
93630
93631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93632   unsigned int jresult ;
93633   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93634   Dali::Toolkit::Slider arg2 ;
93635   float arg3 ;
93636   Dali::Toolkit::Slider *argp2 ;
93637   bool result;
93638
93639   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93640   argp2 = (Dali::Toolkit::Slider *)jarg2;
93641   if (!argp2) {
93642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93643     return 0;
93644   }
93645   arg2 = *argp2;
93646   arg3 = (float)jarg3;
93647   {
93648     try {
93649       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93650     } catch (std::out_of_range& e) {
93651       {
93652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93653       };
93654     } catch (std::exception& e) {
93655       {
93656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93657       };
93658     } catch (Dali::DaliException e) {
93659       {
93660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93661       };
93662     } catch (...) {
93663       {
93664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93665       };
93666     }
93667   }
93668
93669   jresult = result;
93670   return jresult;
93671 }
93672
93673
93674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93675   void * jresult ;
93676   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93677
93678   {
93679     try {
93680       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93681     } catch (std::out_of_range& e) {
93682       {
93683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93684       };
93685     } catch (std::exception& e) {
93686       {
93687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93688       };
93689     } catch (Dali::DaliException e) {
93690       {
93691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93692       };
93693     } catch (...) {
93694       {
93695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93696       };
93697     }
93698   }
93699
93700   jresult = (void *)result;
93701   return jresult;
93702 }
93703
93704
93705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93706   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93707
93708   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93709   {
93710     try {
93711       delete arg1;
93712     } catch (std::out_of_range& e) {
93713       {
93714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93715       };
93716     } catch (std::exception& e) {
93717       {
93718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93719       };
93720     } catch (Dali::DaliException e) {
93721       {
93722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93723       };
93724     } catch (...) {
93725       {
93726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93727       };
93728     }
93729   }
93730
93731 }
93732
93733
93734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93735   unsigned int jresult ;
93736   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93737   bool result;
93738
93739   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93740   {
93741     try {
93742       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93743     } catch (std::out_of_range& e) {
93744       {
93745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93746       };
93747     } catch (std::exception& e) {
93748       {
93749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93750       };
93751     } catch (Dali::DaliException e) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93754       };
93755     } catch (...) {
93756       {
93757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93758       };
93759     }
93760   }
93761
93762   jresult = result;
93763   return jresult;
93764 }
93765
93766
93767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93768   unsigned long jresult ;
93769   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93770   std::size_t result;
93771
93772   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93773   {
93774     try {
93775       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93776     } catch (std::out_of_range& e) {
93777       {
93778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93779       };
93780     } catch (std::exception& e) {
93781       {
93782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93783       };
93784     } catch (Dali::DaliException e) {
93785       {
93786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93787       };
93788     } catch (...) {
93789       {
93790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93791       };
93792     }
93793   }
93794
93795   jresult = (unsigned long)result;
93796   return jresult;
93797 }
93798
93799
93800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93801   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93802   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93803
93804   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93805   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93806   {
93807     try {
93808       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93809     } catch (std::out_of_range& e) {
93810       {
93811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93812       };
93813     } catch (std::exception& e) {
93814       {
93815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93816       };
93817     } catch (Dali::DaliException e) {
93818       {
93819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93820       };
93821     } catch (...) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93824       };
93825     }
93826   }
93827
93828 }
93829
93830
93831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93832   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93833   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93834
93835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93836   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93837   {
93838     try {
93839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93840     } catch (std::out_of_range& e) {
93841       {
93842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93843       };
93844     } catch (std::exception& e) {
93845       {
93846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93847       };
93848     } catch (Dali::DaliException e) {
93849       {
93850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93851       };
93852     } catch (...) {
93853       {
93854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93855       };
93856     }
93857   }
93858
93859 }
93860
93861
93862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93863   unsigned int jresult ;
93864   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93865   Dali::Toolkit::Slider arg2 ;
93866   int arg3 ;
93867   Dali::Toolkit::Slider *argp2 ;
93868   bool result;
93869
93870   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93871   argp2 = (Dali::Toolkit::Slider *)jarg2;
93872   if (!argp2) {
93873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93874     return 0;
93875   }
93876   arg2 = *argp2;
93877   arg3 = (int)jarg3;
93878   {
93879     try {
93880       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93881     } catch (std::out_of_range& e) {
93882       {
93883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93884       };
93885     } catch (std::exception& e) {
93886       {
93887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93888       };
93889     } catch (Dali::DaliException e) {
93890       {
93891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93892       };
93893     } catch (...) {
93894       {
93895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93896       };
93897     }
93898   }
93899
93900   jresult = result;
93901   return jresult;
93902 }
93903
93904
93905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93906   void * jresult ;
93907   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93908
93909   {
93910     try {
93911       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93912     } catch (std::out_of_range& e) {
93913       {
93914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93915       };
93916     } catch (std::exception& e) {
93917       {
93918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93919       };
93920     } catch (Dali::DaliException e) {
93921       {
93922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93923       };
93924     } catch (...) {
93925       {
93926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93927       };
93928     }
93929   }
93930
93931   jresult = (void *)result;
93932   return jresult;
93933 }
93934
93935
93936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93937   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93938
93939   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93940   {
93941     try {
93942       delete arg1;
93943     } catch (std::out_of_range& e) {
93944       {
93945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93946       };
93947     } catch (std::exception& e) {
93948       {
93949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93950       };
93951     } catch (Dali::DaliException e) {
93952       {
93953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93954       };
93955     } catch (...) {
93956       {
93957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93958       };
93959     }
93960   }
93961
93962 }
93963
93964
93965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93966   void * jresult ;
93967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93968
93969   {
93970     try {
93971       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93972     } catch (std::out_of_range& e) {
93973       {
93974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93975       };
93976     } catch (std::exception& e) {
93977       {
93978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93979       };
93980     } catch (Dali::DaliException e) {
93981       {
93982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93983       };
93984     } catch (...) {
93985       {
93986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93987       };
93988     }
93989   }
93990
93991   jresult = (void *)result;
93992   return jresult;
93993 }
93994
93995
93996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93997   void * jresult ;
93998   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94000
94001   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94002   {
94003     try {
94004       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94005     } catch (std::out_of_range& e) {
94006       {
94007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94008       };
94009     } catch (std::exception& e) {
94010       {
94011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94012       };
94013     } catch (Dali::DaliException e) {
94014       {
94015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94016       };
94017     } catch (...) {
94018       {
94019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94020       };
94021     }
94022   }
94023
94024   jresult = (void *)result;
94025   return jresult;
94026 }
94027
94028
94029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94030   void * jresult ;
94031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94033
94034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94035   if (!arg1) {
94036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94037     return 0;
94038   }
94039   {
94040     try {
94041       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94042     } catch (std::out_of_range& e) {
94043       {
94044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94045       };
94046     } catch (std::exception& e) {
94047       {
94048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94049       };
94050     } catch (Dali::DaliException e) {
94051       {
94052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94053       };
94054     } catch (...) {
94055       {
94056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94057       };
94058     }
94059   }
94060
94061   jresult = (void *)result;
94062   return jresult;
94063 }
94064
94065
94066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94067   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94068
94069   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94070   {
94071     try {
94072       delete arg1;
94073     } catch (std::out_of_range& e) {
94074       {
94075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94076       };
94077     } catch (std::exception& e) {
94078       {
94079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94080       };
94081     } catch (Dali::DaliException e) {
94082       {
94083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94084       };
94085     } catch (...) {
94086       {
94087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94088       };
94089     }
94090   }
94091
94092 }
94093
94094
94095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94096   void * jresult ;
94097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94098   Dali::Toolkit::Ruler *result = 0 ;
94099
94100   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94101   {
94102     try {
94103       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94104     } catch (std::out_of_range& e) {
94105       {
94106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94107       };
94108     } catch (std::exception& e) {
94109       {
94110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94111       };
94112     } catch (Dali::DaliException e) {
94113       {
94114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94115       };
94116     } catch (...) {
94117       {
94118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94119       };
94120     }
94121   }
94122
94123   jresult = (void *)result;
94124   return jresult;
94125 }
94126
94127
94128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94129   void * jresult ;
94130   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94131   Dali::Toolkit::Ruler *result = 0 ;
94132
94133   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94134   {
94135     try {
94136       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94137     } catch (std::out_of_range& e) {
94138       {
94139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94140       };
94141     } catch (std::exception& e) {
94142       {
94143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94144       };
94145     } catch (Dali::DaliException e) {
94146       {
94147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94148       };
94149     } catch (...) {
94150       {
94151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94152       };
94153     }
94154   }
94155
94156   jresult = (void *)result;
94157   return jresult;
94158 }
94159
94160
94161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94162   void * jresult ;
94163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94164   Dali::Toolkit::Ruler *result = 0 ;
94165
94166   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94167   {
94168     try {
94169       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94170     } catch (std::out_of_range& e) {
94171       {
94172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94173       };
94174     } catch (std::exception& e) {
94175       {
94176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94177       };
94178     } catch (Dali::DaliException e) {
94179       {
94180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94181       };
94182     } catch (...) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94185       };
94186     }
94187   }
94188
94189   jresult = (void *)result;
94190   return jresult;
94191 }
94192
94193
94194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94195   void * jresult ;
94196   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94197   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94199
94200   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94201   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94202   if (!arg2) {
94203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94204     return 0;
94205   }
94206   {
94207     try {
94208       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94209     } catch (std::out_of_range& e) {
94210       {
94211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94212       };
94213     } catch (std::exception& e) {
94214       {
94215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94216       };
94217     } catch (Dali::DaliException e) {
94218       {
94219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94220       };
94221     } catch (...) {
94222       {
94223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94224       };
94225     }
94226   }
94227
94228   jresult = (void *)result;
94229   return jresult;
94230 }
94231
94232
94233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94234   void * jresult ;
94235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94236   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94237   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94238
94239   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94240   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94241   {
94242     try {
94243       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94244     } catch (std::out_of_range& e) {
94245       {
94246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94247       };
94248     } catch (std::exception& e) {
94249       {
94250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94251       };
94252     } catch (Dali::DaliException e) {
94253       {
94254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94255       };
94256     } catch (...) {
94257       {
94258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94259       };
94260     }
94261   }
94262
94263   jresult = (void *)result;
94264   return jresult;
94265 }
94266
94267
94268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94269   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94270
94271   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94272   {
94273     try {
94274       (arg1)->Reset();
94275     } catch (std::out_of_range& e) {
94276       {
94277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94278       };
94279     } catch (std::exception& e) {
94280       {
94281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94282       };
94283     } catch (Dali::DaliException e) {
94284       {
94285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94286       };
94287     } catch (...) {
94288       {
94289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94290       };
94291     }
94292   }
94293
94294 }
94295
94296
94297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94299   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94300
94301   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94302   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94303   {
94304     try {
94305       (arg1)->Reset(arg2);
94306     } catch (std::out_of_range& e) {
94307       {
94308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94309       };
94310     } catch (std::exception& e) {
94311       {
94312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94313       };
94314     } catch (Dali::DaliException e) {
94315       {
94316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94317       };
94318     } catch (...) {
94319       {
94320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94321       };
94322     }
94323   }
94324
94325 }
94326
94327
94328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94329   void * jresult ;
94330   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94331   Dali::Toolkit::Ruler *result = 0 ;
94332
94333   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94334   {
94335     try {
94336       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94337     } catch (std::out_of_range& e) {
94338       {
94339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94340       };
94341     } catch (std::exception& e) {
94342       {
94343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94344       };
94345     } catch (Dali::DaliException e) {
94346       {
94347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94348       };
94349     } catch (...) {
94350       {
94351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94352       };
94353     }
94354   }
94355
94356   jresult = (void *)result;
94357   return jresult;
94358 }
94359
94360
94361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94362   float jresult ;
94363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94364   float arg2 ;
94365   float arg3 ;
94366   float result;
94367
94368   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94369   arg2 = (float)jarg2;
94370   arg3 = (float)jarg3;
94371   {
94372     try {
94373       result = (float)(*arg1)->Snap(arg2,arg3);
94374     } catch (std::out_of_range& e) {
94375       {
94376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94377       };
94378     } catch (std::exception& e) {
94379       {
94380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94381       };
94382     } catch (Dali::DaliException e) {
94383       {
94384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94385       };
94386     } catch (...) {
94387       {
94388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94389       };
94390     }
94391   }
94392
94393   jresult = result;
94394   return jresult;
94395 }
94396
94397
94398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94399   float jresult ;
94400   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94401   float arg2 ;
94402   float result;
94403
94404   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94405   arg2 = (float)jarg2;
94406   {
94407     try {
94408       result = (float)(*arg1)->Snap(arg2);
94409     } catch (std::out_of_range& e) {
94410       {
94411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94412       };
94413     } catch (std::exception& e) {
94414       {
94415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94416       };
94417     } catch (Dali::DaliException e) {
94418       {
94419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94420       };
94421     } catch (...) {
94422       {
94423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94424       };
94425     }
94426   }
94427
94428   jresult = result;
94429   return jresult;
94430 }
94431
94432
94433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94434   float jresult ;
94435   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94436   unsigned int arg2 ;
94437   unsigned int *arg3 = 0 ;
94438   bool arg4 ;
94439   float result;
94440
94441   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94442   arg2 = (unsigned int)jarg2;
94443   arg3 = (unsigned int *)jarg3;
94444   arg4 = jarg4 ? true : false;
94445   {
94446     try {
94447       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94448     } catch (std::out_of_range& e) {
94449       {
94450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94451       };
94452     } catch (std::exception& e) {
94453       {
94454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94455       };
94456     } catch (Dali::DaliException e) {
94457       {
94458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94459       };
94460     } catch (...) {
94461       {
94462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94463       };
94464     }
94465   }
94466
94467   jresult = result;
94468   return jresult;
94469 }
94470
94471
94472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94473   unsigned int jresult ;
94474   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94475   float arg2 ;
94476   bool arg3 ;
94477   unsigned int result;
94478
94479   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94480   arg2 = (float)jarg2;
94481   arg3 = jarg3 ? true : false;
94482   {
94483     try {
94484       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94485     } catch (std::out_of_range& e) {
94486       {
94487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94488       };
94489     } catch (std::exception& e) {
94490       {
94491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94492       };
94493     } catch (Dali::DaliException e) {
94494       {
94495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94496       };
94497     } catch (...) {
94498       {
94499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94500       };
94501     }
94502   }
94503
94504   jresult = result;
94505   return jresult;
94506 }
94507
94508
94509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94510   unsigned int jresult ;
94511   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94512   unsigned int result;
94513
94514   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94515   {
94516     try {
94517       result = (unsigned int)(*arg1)->GetTotalPages();
94518     } catch (std::out_of_range& e) {
94519       {
94520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94521       };
94522     } catch (std::exception& e) {
94523       {
94524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94525       };
94526     } catch (Dali::DaliException e) {
94527       {
94528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94529       };
94530     } catch (...) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94533       };
94534     }
94535   }
94536
94537   jresult = result;
94538   return jresult;
94539 }
94540
94541
94542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94543   int jresult ;
94544   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94545   Dali::Toolkit::Ruler::RulerType result;
94546
94547   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94548   {
94549     try {
94550       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94551     } catch (std::out_of_range& e) {
94552       {
94553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94554       };
94555     } catch (std::exception& e) {
94556       {
94557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94558       };
94559     } catch (Dali::DaliException e) {
94560       {
94561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94562       };
94563     } catch (...) {
94564       {
94565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94566       };
94567     }
94568   }
94569
94570   jresult = (int)result;
94571   return jresult;
94572 }
94573
94574
94575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94576   unsigned int jresult ;
94577   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94578   bool result;
94579
94580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94581   {
94582     try {
94583       result = (bool)(*arg1)->IsEnabled();
94584     } catch (std::out_of_range& e) {
94585       {
94586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94587       };
94588     } catch (std::exception& e) {
94589       {
94590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (Dali::DaliException e) {
94593       {
94594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94595       };
94596     } catch (...) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94599       };
94600     }
94601   }
94602
94603   jresult = result;
94604   return jresult;
94605 }
94606
94607
94608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94609   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94610
94611   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94612   {
94613     try {
94614       (*arg1)->Enable();
94615     } catch (std::out_of_range& e) {
94616       {
94617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94618       };
94619     } catch (std::exception& e) {
94620       {
94621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94622       };
94623     } catch (Dali::DaliException e) {
94624       {
94625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94626       };
94627     } catch (...) {
94628       {
94629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94630       };
94631     }
94632   }
94633
94634 }
94635
94636
94637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94638   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94639
94640   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94641   {
94642     try {
94643       (*arg1)->Disable();
94644     } catch (std::out_of_range& e) {
94645       {
94646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94647       };
94648     } catch (std::exception& e) {
94649       {
94650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94651       };
94652     } catch (Dali::DaliException e) {
94653       {
94654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94655       };
94656     } catch (...) {
94657       {
94658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94659       };
94660     }
94661   }
94662
94663 }
94664
94665
94666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94667   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94668   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94669   Dali::Toolkit::RulerDomain *argp2 ;
94670
94671   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94672   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94673   if (!argp2) {
94674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94675     return ;
94676   }
94677   arg2 = *argp2;
94678   {
94679     try {
94680       (*arg1)->SetDomain(arg2);
94681     } catch (std::out_of_range& e) {
94682       {
94683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94684       };
94685     } catch (std::exception& e) {
94686       {
94687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94688       };
94689     } catch (Dali::DaliException e) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94692       };
94693     } catch (...) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94696       };
94697     }
94698   }
94699
94700 }
94701
94702
94703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94704   void * jresult ;
94705   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94706   Dali::Toolkit::RulerDomain *result = 0 ;
94707
94708   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94709   {
94710     try {
94711       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94712     } catch (std::out_of_range& e) {
94713       {
94714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94715       };
94716     } catch (std::exception& e) {
94717       {
94718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94719       };
94720     } catch (Dali::DaliException e) {
94721       {
94722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94723       };
94724     } catch (...) {
94725       {
94726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94727       };
94728     }
94729   }
94730
94731   jresult = (void *)result;
94732   return jresult;
94733 }
94734
94735
94736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94737   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94738
94739   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94740   {
94741     try {
94742       (*arg1)->DisableDomain();
94743     } catch (std::out_of_range& e) {
94744       {
94745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94746       };
94747     } catch (std::exception& e) {
94748       {
94749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94750       };
94751     } catch (Dali::DaliException e) {
94752       {
94753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94754       };
94755     } catch (...) {
94756       {
94757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94758       };
94759     }
94760   }
94761
94762 }
94763
94764
94765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94766   float jresult ;
94767   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94768   float arg2 ;
94769   float arg3 ;
94770   float arg4 ;
94771   float result;
94772
94773   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94774   arg2 = (float)jarg2;
94775   arg3 = (float)jarg3;
94776   arg4 = (float)jarg4;
94777   {
94778     try {
94779       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94780     } catch (std::out_of_range& e) {
94781       {
94782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94783       };
94784     } catch (std::exception& e) {
94785       {
94786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94787       };
94788     } catch (Dali::DaliException e) {
94789       {
94790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94791       };
94792     } catch (...) {
94793       {
94794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94795       };
94796     }
94797   }
94798
94799   jresult = result;
94800   return jresult;
94801 }
94802
94803
94804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94805   float jresult ;
94806   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94807   float arg2 ;
94808   float arg3 ;
94809   float result;
94810
94811   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94812   arg2 = (float)jarg2;
94813   arg3 = (float)jarg3;
94814   {
94815     try {
94816       result = (float)(*arg1)->Clamp(arg2,arg3);
94817     } catch (std::out_of_range& e) {
94818       {
94819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94820       };
94821     } catch (std::exception& e) {
94822       {
94823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94824       };
94825     } catch (Dali::DaliException e) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94828       };
94829     } catch (...) {
94830       {
94831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94832       };
94833     }
94834   }
94835
94836   jresult = result;
94837   return jresult;
94838 }
94839
94840
94841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94842   float jresult ;
94843   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94844   float arg2 ;
94845   float result;
94846
94847   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94848   arg2 = (float)jarg2;
94849   {
94850     try {
94851       result = (float)(*arg1)->Clamp(arg2);
94852     } catch (std::out_of_range& e) {
94853       {
94854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94855       };
94856     } catch (std::exception& e) {
94857       {
94858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94859       };
94860     } catch (Dali::DaliException e) {
94861       {
94862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94863       };
94864     } catch (...) {
94865       {
94866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94867       };
94868     }
94869   }
94870
94871   jresult = result;
94872   return jresult;
94873 }
94874
94875
94876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94877   float jresult ;
94878   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94879   float arg2 ;
94880   float arg3 ;
94881   float arg4 ;
94882   Dali::Toolkit::ClampState *arg5 = 0 ;
94883   float result;
94884
94885   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94886   arg2 = (float)jarg2;
94887   arg3 = (float)jarg3;
94888   arg4 = (float)jarg4;
94889   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94890   if (!arg5) {
94891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94892     return 0;
94893   }
94894   {
94895     try {
94896       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94897     } catch (std::out_of_range& e) {
94898       {
94899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94900       };
94901     } catch (std::exception& e) {
94902       {
94903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94904       };
94905     } catch (Dali::DaliException e) {
94906       {
94907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94908       };
94909     } catch (...) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94912       };
94913     }
94914   }
94915
94916   jresult = result;
94917   return jresult;
94918 }
94919
94920
94921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94922   float jresult ;
94923   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94924   float arg2 ;
94925   float arg3 ;
94926   float arg4 ;
94927   float arg5 ;
94928   float result;
94929
94930   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94931   arg2 = (float)jarg2;
94932   arg3 = (float)jarg3;
94933   arg4 = (float)jarg4;
94934   arg5 = (float)jarg5;
94935   {
94936     try {
94937       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94938     } catch (std::out_of_range& e) {
94939       {
94940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94941       };
94942     } catch (std::exception& e) {
94943       {
94944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94945       };
94946     } catch (Dali::DaliException e) {
94947       {
94948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94949       };
94950     } catch (...) {
94951       {
94952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94953       };
94954     }
94955   }
94956
94957   jresult = result;
94958   return jresult;
94959 }
94960
94961
94962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94963   float jresult ;
94964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94965   float arg2 ;
94966   float arg3 ;
94967   float arg4 ;
94968   float result;
94969
94970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94971   arg2 = (float)jarg2;
94972   arg3 = (float)jarg3;
94973   arg4 = (float)jarg4;
94974   {
94975     try {
94976       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94977     } catch (std::out_of_range& e) {
94978       {
94979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94980       };
94981     } catch (std::exception& e) {
94982       {
94983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94984       };
94985     } catch (Dali::DaliException e) {
94986       {
94987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94988       };
94989     } catch (...) {
94990       {
94991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94992       };
94993     }
94994   }
94995
94996   jresult = result;
94997   return jresult;
94998 }
94999
95000
95001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95002   float jresult ;
95003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95004   float arg2 ;
95005   float arg3 ;
95006   float result;
95007
95008   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95009   arg2 = (float)jarg2;
95010   arg3 = (float)jarg3;
95011   {
95012     try {
95013       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95014     } catch (std::out_of_range& e) {
95015       {
95016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95017       };
95018     } catch (std::exception& e) {
95019       {
95020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95021       };
95022     } catch (Dali::DaliException e) {
95023       {
95024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95025       };
95026     } catch (...) {
95027       {
95028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95029       };
95030     }
95031   }
95032
95033   jresult = result;
95034   return jresult;
95035 }
95036
95037
95038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95039   float jresult ;
95040   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95041   float arg2 ;
95042   float result;
95043
95044   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95045   arg2 = (float)jarg2;
95046   {
95047     try {
95048       result = (float)(*arg1)->SnapAndClamp(arg2);
95049     } catch (std::out_of_range& e) {
95050       {
95051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95052       };
95053     } catch (std::exception& e) {
95054       {
95055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95056       };
95057     } catch (Dali::DaliException e) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95060       };
95061     } catch (...) {
95062       {
95063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95064       };
95065     }
95066   }
95067
95068   jresult = result;
95069   return jresult;
95070 }
95071
95072
95073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95074   float jresult ;
95075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95076   float arg2 ;
95077   float arg3 ;
95078   float arg4 ;
95079   float arg5 ;
95080   Dali::Toolkit::ClampState *arg6 = 0 ;
95081   float result;
95082
95083   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95084   arg2 = (float)jarg2;
95085   arg3 = (float)jarg3;
95086   arg4 = (float)jarg4;
95087   arg5 = (float)jarg5;
95088   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95089   if (!arg6) {
95090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95091     return 0;
95092   }
95093   {
95094     try {
95095       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95096     } catch (std::out_of_range& e) {
95097       {
95098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95099       };
95100     } catch (std::exception& e) {
95101       {
95102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95103       };
95104     } catch (Dali::DaliException e) {
95105       {
95106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95107       };
95108     } catch (...) {
95109       {
95110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95111       };
95112     }
95113   }
95114
95115   jresult = result;
95116   return jresult;
95117 }
95118
95119
95120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95121   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95122
95123   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95124   {
95125     try {
95126       (*arg1)->Reference();
95127     } catch (std::out_of_range& e) {
95128       {
95129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95130       };
95131     } catch (std::exception& e) {
95132       {
95133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95134       };
95135     } catch (Dali::DaliException e) {
95136       {
95137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95138       };
95139     } catch (...) {
95140       {
95141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95142       };
95143     }
95144   }
95145
95146 }
95147
95148
95149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95150   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95151
95152   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95153   {
95154     try {
95155       (*arg1)->Unreference();
95156     } catch (std::out_of_range& e) {
95157       {
95158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95159       };
95160     } catch (std::exception& e) {
95161       {
95162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95163       };
95164     } catch (Dali::DaliException e) {
95165       {
95166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95167       };
95168     } catch (...) {
95169       {
95170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95171       };
95172     }
95173   }
95174
95175 }
95176
95177
95178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95179   int jresult ;
95180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95181   int result;
95182
95183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95184   {
95185     try {
95186       result = (int)(*arg1)->ReferenceCount();
95187     } catch (std::out_of_range& e) {
95188       {
95189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95190       };
95191     } catch (std::exception& e) {
95192       {
95193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95194       };
95195     } catch (Dali::DaliException e) {
95196       {
95197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95198       };
95199     } catch (...) {
95200       {
95201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95202       };
95203     }
95204   }
95205
95206   jresult = result;
95207   return jresult;
95208 }
95209
95210
95211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95212   unsigned int jresult ;
95213   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95214   bool result;
95215
95216   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95217   {
95218     try {
95219       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95220     } catch (std::out_of_range& e) {
95221       {
95222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95223       };
95224     } catch (std::exception& e) {
95225       {
95226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95227       };
95228     } catch (Dali::DaliException e) {
95229       {
95230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95231       };
95232     } catch (...) {
95233       {
95234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95235       };
95236     }
95237   }
95238
95239   jresult = result;
95240   return jresult;
95241 }
95242
95243
95244 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95245   unsigned long jresult ;
95246   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95247   std::size_t result;
95248
95249   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95250   {
95251     try {
95252       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95253     } catch (std::out_of_range& e) {
95254       {
95255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95256       };
95257     } catch (std::exception& e) {
95258       {
95259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95260       };
95261     } catch (Dali::DaliException e) {
95262       {
95263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95264       };
95265     } catch (...) {
95266       {
95267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95268       };
95269     }
95270   }
95271
95272   jresult = (unsigned long)result;
95273   return jresult;
95274 }
95275
95276
95277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95278   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95279   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95280
95281   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95282   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95283   {
95284     try {
95285       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95286     } catch (std::out_of_range& e) {
95287       {
95288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95289       };
95290     } catch (std::exception& e) {
95291       {
95292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95293       };
95294     } catch (Dali::DaliException e) {
95295       {
95296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95297       };
95298     } catch (...) {
95299       {
95300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95301       };
95302     }
95303   }
95304
95305 }
95306
95307
95308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95309   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95310   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95311
95312   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95313   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95314   {
95315     try {
95316       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95317     } catch (std::out_of_range& e) {
95318       {
95319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95320       };
95321     } catch (std::exception& e) {
95322       {
95323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95324       };
95325     } catch (Dali::DaliException e) {
95326       {
95327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95328       };
95329     } catch (...) {
95330       {
95331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95332       };
95333     }
95334   }
95335
95336 }
95337
95338
95339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95340   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95341   Dali::Toolkit::Control arg2 ;
95342   Dali::Toolkit::Control *argp2 ;
95343
95344   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95345   argp2 = (Dali::Toolkit::Control *)jarg2;
95346   if (!argp2) {
95347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95348     return ;
95349   }
95350   arg2 = *argp2;
95351   {
95352     try {
95353       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95354     } catch (std::out_of_range& e) {
95355       {
95356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95357       };
95358     } catch (std::exception& e) {
95359       {
95360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95361       };
95362     } catch (Dali::DaliException e) {
95363       {
95364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95365       };
95366     } catch (...) {
95367       {
95368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95369       };
95370     }
95371   }
95372
95373 }
95374
95375
95376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95377   void * jresult ;
95378   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95379
95380   {
95381     try {
95382       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95383     } catch (std::out_of_range& e) {
95384       {
95385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95386       };
95387     } catch (std::exception& e) {
95388       {
95389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95390       };
95391     } catch (Dali::DaliException e) {
95392       {
95393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95394       };
95395     } catch (...) {
95396       {
95397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95398       };
95399     }
95400   }
95401
95402   jresult = (void *)result;
95403   return jresult;
95404 }
95405
95406
95407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95408   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95409
95410   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95411   {
95412     try {
95413       delete arg1;
95414     } catch (std::out_of_range& e) {
95415       {
95416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95417       };
95418     } catch (std::exception& e) {
95419       {
95420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95421       };
95422     } catch (Dali::DaliException e) {
95423       {
95424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95425       };
95426     } catch (...) {
95427       {
95428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95429       };
95430     }
95431   }
95432
95433 }
95434
95435 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95436   Dali::RefObject *result = NULL;
95437
95438   if (arg1)
95439   {
95440     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95441   }
95442   return result;
95443 }
95444
95445 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95446     return (Dali::RefObject *)jarg1;
95447 }
95448
95449 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95450     return (Dali::SignalObserver *)jarg1;
95451 }
95452
95453 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95454     return (Dali::ConnectionTrackerInterface *)jarg1;
95455 }
95456
95457 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95458     return (Dali::BaseHandle *)jarg1;
95459 }
95460
95461 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95462     return (Dali::BaseHandle *)jarg1;
95463 }
95464
95465 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95466     return (Dali::BaseHandle *)jarg1;
95467 }
95468
95469 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95470     return (Dali::BaseHandle *)jarg1;
95471 }
95472
95473 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95474     return (Dali::BaseHandle *)jarg1;
95475 }
95476
95477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95478     return (Dali::BaseHandle *)jarg1;
95479 }
95480
95481 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95482     return (Dali::BaseHandle *)jarg1;
95483 }
95484
95485 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95486     return (Dali::BaseHandle *)jarg1;
95487 }
95488
95489 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95490     return (Dali::BaseHandle *)jarg1;
95491 }
95492
95493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95494     return (Dali::BaseHandle *)jarg1;
95495 }
95496
95497 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95498     return (Dali::BaseHandle *)jarg1;
95499 }
95500
95501 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95502     return (Dali::BaseHandle *)jarg1;
95503 }
95504
95505 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95506     return (Dali::Handle *)jarg1;
95507 }
95508
95509 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95510     return (Dali::Handle *)jarg1;
95511 }
95512
95513 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95514     return (Dali::BaseHandle *)jarg1;
95515 }
95516
95517 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95518     return (Dali::BaseHandle *)jarg1;
95519 }
95520
95521 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95522     return (Dali::Handle *)jarg1;
95523 }
95524
95525 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95526     return (Dali::BaseHandle *)jarg1;
95527 }
95528
95529 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95530     return (Dali::BaseHandle *)jarg1;
95531 }
95532
95533 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
95534     return (Dali::BaseHandle *)jarg1;
95535 }
95536
95537 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95538     return (Dali::Handle *)jarg1;
95539 }
95540
95541 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95542     return (Dali::GestureDetector *)jarg1;
95543 }
95544
95545 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95546     return (Dali::Gesture *)jarg1;
95547 }
95548
95549 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95550     return (Dali::Handle *)jarg1;
95551 }
95552
95553 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95554     return (Dali::Actor *)jarg1;
95555 }
95556
95557 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95558     return (Dali::RefObject *)jarg1;
95559 }
95560
95561 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95562     return (Dali::Actor *)jarg1;
95563 }
95564
95565 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95566     return (Dali::GestureDetector *)jarg1;
95567 }
95568
95569 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95570     return (Dali::Gesture *)jarg1;
95571 }
95572
95573 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95574     return (Dali::GestureDetector *)jarg1;
95575 }
95576
95577 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95578     return (Dali::Gesture *)jarg1;
95579 }
95580
95581 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95582     return (Dali::GestureDetector *)jarg1;
95583 }
95584
95585 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95586     return (Dali::Gesture *)jarg1;
95587 }
95588
95589 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95590     return (Dali::BaseHandle *)jarg1;
95591 }
95592
95593 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95594     return (Dali::Handle *)jarg1;
95595 }
95596
95597 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95598     return (Dali::Handle *)jarg1;
95599 }
95600
95601 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95602     return (Dali::Handle *)jarg1;
95603 }
95604
95605 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95606     return (Dali::RefObject *)jarg1;
95607 }
95608
95609 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95610     return (Dali::Actor *)jarg1;
95611 }
95612
95613 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95614     return (Dali::BaseHandle *)jarg1;
95615 }
95616
95617 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95618     return (Dali::BaseHandle *)jarg1;
95619 }
95620
95621 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95622     return (Dali::BaseHandle *)jarg1;
95623 }
95624
95625 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95626     return (Dali::CustomActorImpl *)jarg1;
95627 }
95628
95629 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95630     return (Dali::CustomActor *)jarg1;
95631 }
95632
95633 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95634     return (Dali::BaseHandle *)jarg1;
95635 }
95636
95637 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95638     return (Dali::Toolkit::Control *)jarg1;
95639 }
95640
95641 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95642     return (Dali::Toolkit::Control *)jarg1;
95643 }
95644
95645 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95646     return (Dali::Toolkit::Button *)jarg1;
95647 }
95648
95649 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95650     return (Dali::Toolkit::Button *)jarg1;
95651 }
95652
95653 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95654     return (Dali::Toolkit::Button *)jarg1;
95655 }
95656
95657 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95658     return (Dali::Toolkit::Control *)jarg1;
95659 }
95660
95661 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95662     return (Dali::Toolkit::Control *)jarg1;
95663 }
95664
95665 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95666     return (Dali::Toolkit::Control *)jarg1;
95667 }
95668
95669 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95670     return (Dali::Toolkit::Control *)jarg1;
95671 }
95672
95673 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95674     return (Dali::Toolkit::Control *)jarg1;
95675 }
95676
95677 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95678     return (Dali::RefObject *)jarg1;
95679 }
95680
95681 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95682     return (Dali::Toolkit::Scrollable *)jarg1;
95683 }
95684
95685 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95686     return (Dali::BaseHandle *)jarg1;
95687 }
95688
95689 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95690     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95691 }
95692
95693 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95694     return (Dali::RefObject *)jarg1;
95695 }
95696
95697 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95698     return (Dali::Toolkit::Ruler *)jarg1;
95699 }
95700
95701 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95702     return (Dali::Toolkit::Ruler *)jarg1;
95703 }
95704
95705 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95706     return (Dali::Toolkit::Scrollable *)jarg1;
95707 }
95708
95709 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95710     return (Dali::Toolkit::Control *)jarg1;
95711 }
95712
95713
95714 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95715     return (Dali::Toolkit::Control *)jarg1;
95716 }
95717
95718 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95719     return (Dali::BaseHandle *)jarg1;
95720 }
95721
95722 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95723     return (Dali::BaseHandle *)jarg1;
95724 }
95725
95726 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95727     return (Dali::Toolkit::Control *)jarg1;
95728 }
95729
95730 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95731     return (Dali::Toolkit::Control *)jarg1;
95732 }
95733
95734 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95735     return (Dali::Toolkit::Control *)jarg1;
95736 }
95737
95738 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95739     return (Dali::Toolkit::Control *)jarg1;
95740 }
95741
95742 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95743     return (Dali::Toolkit::Control *)jarg1;
95744 }
95745
95746 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95747     return (Dali::Toolkit::Control *)jarg1;
95748 }
95749
95750 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95751     return (Dali::Toolkit::PageTurnView *)jarg1;
95752 }
95753
95754 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95755     return (Dali::Toolkit::PageTurnView *)jarg1;
95756 }
95757
95758 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95759     return (Dali::Toolkit::Button *)jarg1;
95760 }
95761
95762 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95763     return (Dali::BaseHandle *)jarg1;
95764 }
95765
95766 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95767     return (Dali::BaseHandle *)jarg1;
95768 }
95769
95770 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95771     return (Dali::BaseHandle *)jarg1;
95772 }
95773
95774 /*
95775  * Widget binding
95776  */
95777 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95778     return (Dali::BaseHandle *)jarg1;
95779 }
95780
95781 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95782     return (Dali::BaseObject *)jarg1;
95783 }
95784
95785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95786   void * jresult ;
95787   Dali::Widget result;
95788
95789   {
95790     try {
95791       result = Dali::Widget::New();
95792     } catch (std::out_of_range& e) {
95793       {
95794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95795       };
95796     } catch (std::exception& e) {
95797       {
95798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95799       };
95800     } catch (...) {
95801       {
95802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95803       };
95804     }
95805   }
95806   jresult = new Dali::Widget((const Dali::Widget &)result);
95807   return jresult;
95808 }
95809
95810
95811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95812   void * jresult ;
95813   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95814   Dali::Widget result;
95815
95816   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95817
95818   if (!arg1) {
95819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95820     return 0;
95821   }
95822   {
95823     try {
95824       jresult = new Dali::Widget(arg1);
95825     } catch (std::out_of_range& e) {
95826       {
95827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95828       };
95829     } catch (std::exception& e) {
95830       {
95831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95832       };
95833     } catch (...) {
95834       {
95835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95836       };
95837     }
95838   }
95839   return jresult;
95840 }
95841
95842
95843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95844   void * jresult ;
95845   Dali::Widget *result = 0 ;
95846
95847   {
95848     try {
95849       result = (Dali::Widget *)new Dali::Widget();
95850     } catch (std::out_of_range& e) {
95851       {
95852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95853       };
95854     } catch (std::exception& e) {
95855       {
95856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95857       };
95858     } catch (...) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95861       };
95862     }
95863   }
95864   jresult = (void *)result;
95865   return jresult;
95866 }
95867
95868
95869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95870   void * jresult ;
95871   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95872   Dali::Widget *arg2 = 0 ;
95873   Dali::Widget *result = 0 ;
95874
95875   arg1 = (Dali::Widget *)jarg1;
95876   arg2 = (Dali::Widget *)jarg2;
95877   if (!arg2) {
95878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95879     return 0;
95880   }
95881   {
95882     try {
95883       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95884     } catch (std::out_of_range& e) {
95885       {
95886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95887       };
95888     } catch (std::exception& e) {
95889       {
95890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95891       };
95892     } catch (...) {
95893       {
95894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95895       };
95896     }
95897   }
95898   jresult = (void *)result;
95899   return jresult;
95900 }
95901
95902
95903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95904   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95905
95906   arg1 = (Dali::Widget *)jarg1;
95907   {
95908     try {
95909       delete arg1;
95910     } catch (std::out_of_range& e) {
95911       {
95912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95913       };
95914     } catch (std::exception& e) {
95915       {
95916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95917       };
95918     } catch (...) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95921       };
95922     }
95923   }
95924 }
95925
95926
95927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95928   void * jresult ;
95929   SwigDirector_WidgetImpl* result;
95930   {
95931     try {
95932       result = new SwigDirector_WidgetImpl();
95933     } catch (std::out_of_range& e) {
95934       {
95935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95936       };
95937     } catch (std::exception& e) {
95938       {
95939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95940       };
95941     } catch (...) {
95942       {
95943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95944       };
95945     }
95946   }
95947   jresult = result;
95948   return jresult;
95949 }
95950
95951
95952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95953   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95954   std::string *arg2 = 0 ;
95955   Dali::Window arg3 ;
95956   Dali::Window *argp3 ;
95957
95958   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95959   if (!jarg2) {
95960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95961     return ;
95962   }
95963   std::string arg2_str(jarg2);
95964   arg2 = &arg2_str;
95965   argp3 = (Dali::Window *)jarg3;
95966   if (!argp3) {
95967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95968     return ;
95969   }
95970   arg3 = *argp3;
95971   {
95972     try {
95973       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95974     } catch (std::out_of_range& e) {
95975       {
95976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95977       };
95978     } catch (std::exception& e) {
95979       {
95980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (...) {
95983       {
95984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95985       };
95986     }
95987   }
95988 }
95989
95990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95991   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95992   std::string *arg2 = 0 ;
95993   Dali::Window arg3 ;
95994   Dali::Window *argp3 ;
95995
95996   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95997   if (!jarg2) {
95998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95999     return ;
96000   }
96001   std::string arg2_str(jarg2);
96002   arg2 = &arg2_str;
96003   argp3 = (Dali::Window *)jarg3;
96004   if (!argp3) {
96005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96006     return ;
96007   }
96008   arg3 = *argp3;
96009   {
96010     try {
96011       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96012     } catch (std::out_of_range& e) {
96013       {
96014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96015       };
96016     } catch (std::exception& e) {
96017       {
96018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96019       };
96020     } catch (...) {
96021       {
96022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96023       };
96024     }
96025   }
96026 }
96027
96028
96029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96030   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96031   std::string *arg2 = 0 ;
96032   Dali::Widget::Termination arg3 ;
96033
96034   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96035   if (!jarg2) {
96036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96037     return ;
96038   }
96039   std::string arg2_str(jarg2);
96040   arg2 = &arg2_str;
96041   arg3 = (Dali::Widget::Termination)jarg3;
96042   {
96043     try {
96044       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96045     } catch (std::out_of_range& e) {
96046       {
96047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96048       };
96049     } catch (std::exception& e) {
96050       {
96051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96052       };
96053     } catch (...) {
96054       {
96055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96056       };
96057     }
96058   }
96059 }
96060
96061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96062   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96063   std::string *arg2 = 0 ;
96064   Dali::Widget::Termination arg3 ;
96065
96066   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96067   if (!jarg2) {
96068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96069     return ;
96070   }
96071   std::string arg2_str(jarg2);
96072   arg2 = &arg2_str;
96073   arg3 = (Dali::Widget::Termination)jarg3;
96074   {
96075     try {
96076       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96077     } catch (std::out_of_range& e) {
96078       {
96079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96080       };
96081     } catch (std::exception& e) {
96082       {
96083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96084       };
96085     } catch (...) {
96086       {
96087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96088       };
96089     }
96090   }
96091 }
96092
96093
96094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96095   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96096
96097   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96098   {
96099     try {
96100       (arg1)->OnPause();
96101     } catch (std::out_of_range& e) {
96102       {
96103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96104       };
96105     } catch (std::exception& e) {
96106       {
96107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96108       };
96109     } catch (...) {
96110       {
96111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96112       };
96113     }
96114   }
96115 }
96116
96117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96118   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96119
96120   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96121   {
96122     try {
96123       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96124     } catch (std::out_of_range& e) {
96125       {
96126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96127       };
96128     } catch (std::exception& e) {
96129       {
96130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96131       };
96132     } catch (...) {
96133       {
96134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96135       };
96136     }
96137   }
96138 }
96139
96140
96141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96142   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96143
96144   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96145   {
96146     try {
96147       (arg1)->OnResume();
96148     } catch (std::out_of_range& e) {
96149       {
96150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96151       };
96152     } catch (std::exception& e) {
96153       {
96154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96155       };
96156     } catch (...) {
96157       {
96158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96159       };
96160     }
96161   }
96162 }
96163
96164
96165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96166   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96167
96168   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96169   {
96170     try {
96171       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96172     } catch (std::out_of_range& e) {
96173       {
96174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96175       };
96176     } catch (std::exception& e) {
96177       {
96178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96179       };
96180     } catch (...) {
96181       {
96182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96183       };
96184     }
96185   }
96186 }
96187
96188
96189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96190   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96191   Dali::Window arg2 ;
96192   Dali::Window *argp2 ;
96193
96194   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96195   argp2 = (Dali::Window *)jarg2;
96196   if (!argp2) {
96197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96198     return ;
96199   }
96200   arg2 = *argp2;
96201   {
96202     try {
96203       (arg1)->OnResize(arg2);
96204     } catch (std::out_of_range& e) {
96205       {
96206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96207       };
96208     } catch (std::exception& e) {
96209       {
96210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96211       };
96212     } catch (...) {
96213       {
96214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96215       };
96216     }
96217   }
96218 }
96219
96220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96221   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96222   Dali::Window arg2 ;
96223   Dali::Window *argp2 ;
96224
96225   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96226   argp2 = (Dali::Window *)jarg2;
96227   if (!argp2) {
96228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96229     return ;
96230   }
96231   arg2 = *argp2;
96232   {
96233     try {
96234       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96235     } catch (std::out_of_range& e) {
96236       {
96237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96238       };
96239     } catch (std::exception& e) {
96240       {
96241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96242       };
96243     } catch (...) {
96244       {
96245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96246       };
96247     }
96248   }
96249 }
96250
96251
96252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96253   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96254   std::string *arg2 = 0 ;
96255   int arg3 ;
96256
96257   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96258   if (!jarg2) {
96259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96260     return ;
96261   }
96262   std::string arg2_str(jarg2);
96263   arg2 = &arg2_str;
96264   arg3 = (int)jarg3;
96265   {
96266     try {
96267       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96268     } catch (std::out_of_range& e) {
96269       {
96270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96271       };
96272     } catch (std::exception& e) {
96273       {
96274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96275       };
96276     } catch (...) {
96277       {
96278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96279       };
96280     }
96281   }
96282 }
96283
96284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96285   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96286   std::string *arg2 = 0 ;
96287   int arg3 ;
96288
96289   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96290   if (!jarg2) {
96291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96292     return ;
96293   }
96294   std::string arg2_str(jarg2);
96295   arg2 = &arg2_str;
96296   arg3 = (int)jarg3;
96297   {
96298     try {
96299       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96300     } catch (std::out_of_range& e) {
96301       {
96302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96303       };
96304     } catch (std::exception& e) {
96305       {
96306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96307       };
96308     } catch (...) {
96309       {
96310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96311       };
96312     }
96313   }
96314 }
96315
96316
96317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96318   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96319   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96320   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96321
96322   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96323   arg2 = (Dali::SlotObserver *)jarg2;
96324   arg3 = (Dali::CallbackBase *)jarg3;
96325   {
96326     try {
96327       (arg1)->SignalConnected(arg2,arg3);
96328     } catch (std::out_of_range& e) {
96329       {
96330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96331       };
96332     } catch (std::exception& e) {
96333       {
96334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96335       };
96336     } catch (...) {
96337       {
96338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96339       };
96340     }
96341   }
96342 }
96343
96344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96345   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96346   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96347   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96348
96349   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96350   arg2 = (Dali::SlotObserver *)jarg2;
96351   arg3 = (Dali::CallbackBase *)jarg3;
96352   {
96353     try {
96354       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96355     } catch (std::out_of_range& e) {
96356       {
96357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96358       };
96359     } catch (std::exception& e) {
96360       {
96361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96362       };
96363     } catch (...) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96366       };
96367     }
96368   }
96369 }
96370
96371
96372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96373   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96374   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96375   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96376
96377   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96378   arg2 = (Dali::SlotObserver *)jarg2;
96379   arg3 = (Dali::CallbackBase *)jarg3;
96380   {
96381     try {
96382       (arg1)->SignalDisconnected(arg2,arg3);
96383     } catch (std::out_of_range& e) {
96384       {
96385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96386       };
96387     } catch (std::exception& e) {
96388       {
96389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96390       };
96391     } catch (...) {
96392       {
96393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96394       };
96395     }
96396   }
96397 }
96398
96399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96400   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96401   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96402   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96403
96404   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96405   arg2 = (Dali::SlotObserver *)jarg2;
96406   arg3 = (Dali::CallbackBase *)jarg3;
96407   {
96408     try {
96409       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96410     } catch (std::out_of_range& e) {
96411       {
96412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96413       };
96414     } catch (std::exception& e) {
96415       {
96416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96417       };
96418     } catch (...) {
96419       {
96420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96421       };
96422     }
96423   }
96424 }
96425
96426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96427   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96428   std::string *arg2 = 0 ;
96429
96430   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96431   if (!jarg2) {
96432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96433     return ;
96434   }
96435   std::string arg2_str(jarg2);
96436   arg2 = &arg2_str;
96437   {
96438     try {
96439       (arg1)->SetContentInfo((std::string const &)*arg2);
96440     } catch (std::out_of_range& e) {
96441       {
96442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96443       };
96444     } catch (std::exception& e) {
96445       {
96446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96447       };
96448     } catch (...) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96451       };
96452     }
96453   }
96454 }
96455
96456
96457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96458   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96459   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96460
96461   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96462   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96463   {
96464     try {
96465       (arg1)->SetImpl(arg2);
96466     } catch (std::out_of_range& e) {
96467       {
96468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96469       };
96470     } catch (std::exception& e) {
96471       {
96472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96473       };
96474     } catch (...) {
96475       {
96476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96477       };
96478     }
96479   }
96480 }
96481
96482 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) {
96483
96484   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96485   if (director) {
96486     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96487   }
96488 }
96489
96490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96491   void * jresult ;
96492   Dali::Widget *arg1 = 0 ;
96493   SwigDirector_WidgetImpl *result = 0 ;
96494
96495   arg1 = (Dali::Widget *)jarg1;
96496   if (!arg1) {
96497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96498     return 0;
96499   }
96500   {
96501     try {
96502       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96503     } catch (std::out_of_range& e) {
96504       {
96505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96506       };
96507     } catch (std::exception& e) {
96508       {
96509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96510       };
96511     } catch (...) {
96512       {
96513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96514       };
96515     }
96516   }
96517
96518   jresult = (void *)result;
96519   return jresult;
96520 }
96521
96522
96523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96524   void * jresult ;
96525   int *arg1 = (int *) 0 ;
96526   char ***arg2 ;
96527   std::string *arg3 = 0 ;
96528   Dali::WidgetApplication result;
96529   {
96530     int index = 0;
96531     int length = 0;
96532     char *retPtr;
96533     char *nextPtr;
96534     argWidgetC = jarg1;
96535     argWidgetV = new char*[jarg1 + 1];
96536
96537     retPtr = strtok_r( jarg2, " ", &nextPtr);
96538     if( retPtr )
96539     {
96540       length = strlen(retPtr);
96541     }
96542     argWidgetV[index] = new char[length + 1];
96543     if( retPtr )
96544     {
96545       strncpy(argWidgetV[index], retPtr, length);
96546     }
96547     argWidgetV[index][length] = '\0';
96548     index++;
96549
96550     while (index < jarg1)
96551     {
96552       length = 0;
96553       retPtr = strtok_r(NULL, " ", &nextPtr);
96554       if( retPtr )
96555       {
96556         length = strlen(retPtr);
96557       }
96558       argWidgetV[index] = new char[length + 1];
96559       if( retPtr )
96560       {
96561         strncpy(argWidgetV[index], retPtr, length);
96562       }
96563       argWidgetV[index][length] = '\0';
96564       index++;
96565     }
96566
96567     argWidgetV[jarg1] = NULL;
96568     argWidgetC = jarg1;
96569
96570     arg1 = &argWidgetC;
96571     arg2 = &argWidgetV;
96572   }
96573
96574   if (!jarg3) {
96575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96576     return 0;
96577   }
96578   std::string arg3_str(jarg3);
96579   arg3 = &arg3_str;
96580   {
96581     try {
96582       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96583     } catch (std::out_of_range& e) {
96584       {
96585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96586       };
96587     } catch (std::exception& e) {
96588       {
96589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96590       };
96591     } catch (...) {
96592       {
96593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96594       };
96595     }
96596   }
96597   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96598
96599   return jresult;
96600 }
96601
96602
96603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96604   void * jresult ;
96605   Dali::WidgetApplication *result = 0 ;
96606
96607   {
96608     try {
96609       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96610     } catch (std::out_of_range& e) {
96611       {
96612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96613       };
96614     } catch (std::exception& e) {
96615       {
96616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96617       };
96618     } catch (...) {
96619       {
96620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96621       };
96622     }
96623   }
96624   jresult = (void *)result;
96625   return jresult;
96626 }
96627
96628
96629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96630   void * jresult ;
96631   Dali::WidgetApplication *arg1 = 0 ;
96632   Dali::WidgetApplication *result = 0 ;
96633
96634   arg1 = (Dali::WidgetApplication *)jarg1;
96635   if (!arg1) {
96636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96637     return 0;
96638   }
96639   {
96640     try {
96641       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96642     } catch (std::out_of_range& e) {
96643       {
96644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96645       };
96646     } catch (std::exception& e) {
96647       {
96648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96649       };
96650     } catch (...) {
96651       {
96652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96653       };
96654     }
96655   }
96656   jresult = (void *)result;
96657   return jresult;
96658 }
96659
96660
96661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96662   void * jresult ;
96663   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96664   Dali::WidgetApplication *arg2 = 0 ;
96665   Dali::WidgetApplication *result = 0 ;
96666
96667   arg1 = (Dali::WidgetApplication *)jarg1;
96668   arg2 = (Dali::WidgetApplication *)jarg2;
96669   if (!arg2) {
96670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96671     return 0;
96672   }
96673   {
96674     try {
96675       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96676     } catch (std::out_of_range& e) {
96677       {
96678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96679       };
96680     } catch (std::exception& e) {
96681       {
96682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96683       };
96684     } catch (...) {
96685       {
96686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96687       };
96688     }
96689   }
96690   jresult = (void *)result;
96691   return jresult;
96692 }
96693
96694
96695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96696   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96697
96698   arg1 = (Dali::WidgetApplication *)jarg1;
96699   {
96700     try {
96701       delete arg1;
96702       if( argWidgetV )
96703       {
96704         // free string data
96705         for( int i=0; i < argWidgetC+1; i++)
96706         {
96707           delete [] argWidgetV[i];
96708         }
96709         delete [] argWidgetV;
96710       }
96711     } catch (std::out_of_range& e) {
96712       {
96713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96714       };
96715     } catch (std::exception& e) {
96716       {
96717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96718       };
96719     } catch (...) {
96720       {
96721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96722       };
96723     }
96724   }
96725 }
96726
96727
96728 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96729 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96730
96731 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96732 {
96733   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96734   return *widget;
96735 }
96736
96737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96738   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96739   std::string *arg2 = 0 ;
96740
96741   arg1 = (Dali::WidgetApplication *)jarg1;
96742   if (!jarg2) {
96743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96744     return ;
96745   }
96746   std::string arg2_str(*jarg2);
96747   arg2 = &arg2_str;
96748
96749   if(!_CSharpCreateWidgetFunction)
96750   {
96751     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96752   }
96753
96754   {
96755     try {
96756       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96757     } catch (std::out_of_range& e) {
96758       {
96759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96760       };
96761     } catch (std::exception& e) {
96762       {
96763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96764       };
96765     } catch (...) {
96766       {
96767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96768       };
96769     }
96770   }
96771
96772   //Typemap argout in c++ file.
96773   //This will convert c++ string to c# string
96774   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96775 }
96776
96777
96778 //for PixelBuffer and ImageLoading
96779
96780 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96781     return (Dali::BaseHandle *)jarg1;
96782 }
96783
96784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96785   void * jresult ;
96786   unsigned int arg1 ;
96787   unsigned int arg2 ;
96788   Dali::Pixel::Format arg3 ;
96789   Dali::Devel::PixelBuffer result;
96790
96791   arg1 = (unsigned int)jarg1;
96792   arg2 = (unsigned int)jarg2;
96793   arg3 = (Dali::Pixel::Format)jarg3;
96794   {
96795     try {
96796       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96797     } catch (std::out_of_range& e) {
96798       {
96799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96800       };
96801     } catch (std::exception& e) {
96802       {
96803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96804       };
96805     } catch (...) {
96806       {
96807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96808       };
96809     }
96810   }
96811   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96812   return jresult;
96813 }
96814
96815
96816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96817   void * jresult ;
96818   Dali::Devel::PixelBuffer *result = 0 ;
96819
96820   {
96821     try {
96822       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96823     } catch (std::out_of_range& e) {
96824       {
96825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96826       };
96827     } catch (std::exception& e) {
96828       {
96829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (...) {
96832       {
96833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96834       };
96835     }
96836   }
96837   jresult = (void *)result;
96838   return jresult;
96839 }
96840
96841
96842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96843   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96844
96845   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96846   {
96847     try {
96848       delete arg1;
96849     } catch (std::out_of_range& e) {
96850       {
96851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96852       };
96853     } catch (std::exception& e) {
96854       {
96855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96856       };
96857     } catch (...) {
96858       {
96859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96860       };
96861     }
96862   }
96863 }
96864
96865
96866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96867   void * jresult ;
96868   Dali::Devel::PixelBuffer *arg1 = 0 ;
96869   Dali::Devel::PixelBuffer *result = 0 ;
96870
96871   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96872   if (!arg1) {
96873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96874     return 0;
96875   }
96876   {
96877     try {
96878       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96879     } catch (std::out_of_range& e) {
96880       {
96881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96882       };
96883     } catch (std::exception& e) {
96884       {
96885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96886       };
96887     } catch (...) {
96888       {
96889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96890       };
96891     }
96892   }
96893   jresult = (void *)result;
96894   return jresult;
96895 }
96896
96897
96898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96899   void * jresult ;
96900   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96901   Dali::Devel::PixelBuffer *arg2 = 0 ;
96902   Dali::Devel::PixelBuffer *result = 0 ;
96903
96904   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96905   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96906   if (!arg2) {
96907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96908     return 0;
96909   }
96910   {
96911     try {
96912       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96913     } catch (std::out_of_range& e) {
96914       {
96915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96916       };
96917     } catch (std::exception& e) {
96918       {
96919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96920       };
96921     } catch (...) {
96922       {
96923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96924       };
96925     }
96926   }
96927   jresult = (void *)result;
96928   return jresult;
96929 }
96930
96931
96932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96933   void * jresult ;
96934   Dali::Devel::PixelBuffer *arg1 = 0 ;
96935   Dali::PixelData result;
96936
96937   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96938   if (!arg1) {
96939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96940     return 0;
96941   }
96942   {
96943     try {
96944       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96945     } catch (std::out_of_range& e) {
96946       {
96947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96948       };
96949     } catch (std::exception& e) {
96950       {
96951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96952       };
96953     } catch (...) {
96954       {
96955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96956       };
96957     }
96958   }
96959   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96960   return jresult;
96961 }
96962
96963
96964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96965   void * jresult ;
96966   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96967   Dali::PixelData result;
96968
96969   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96970   {
96971     try {
96972       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96973     } catch (std::out_of_range& e) {
96974       {
96975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96976       };
96977     } catch (std::exception& e) {
96978       {
96979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96980       };
96981     } catch (...) {
96982       {
96983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96984       };
96985     }
96986   }
96987   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96988   return jresult;
96989 }
96990
96991
96992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96993   void * jresult ;
96994   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96995   unsigned char *result = 0 ;
96996
96997   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96998   {
96999     try {
97000       result = (unsigned char *)(arg1)->GetBuffer();
97001     } catch (std::out_of_range& e) {
97002       {
97003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97004       };
97005     } catch (std::exception& e) {
97006       {
97007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97008       };
97009     } catch (...) {
97010       {
97011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97012       };
97013     }
97014   }
97015   jresult = (void *)result;
97016   return jresult;
97017 }
97018
97019
97020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97021   unsigned int jresult ;
97022   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97023   unsigned int result;
97024
97025   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97026   {
97027     try {
97028       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97029     } catch (std::out_of_range& e) {
97030       {
97031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97032       };
97033     } catch (std::exception& e) {
97034       {
97035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97036       };
97037     } catch (...) {
97038       {
97039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97040       };
97041     }
97042   }
97043   jresult = result;
97044   return jresult;
97045 }
97046
97047
97048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97049   unsigned int jresult ;
97050   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97051   unsigned int result;
97052
97053   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97054   {
97055     try {
97056       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97057     } catch (std::out_of_range& e) {
97058       {
97059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97060       };
97061     } catch (std::exception& e) {
97062       {
97063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97064       };
97065     } catch (...) {
97066       {
97067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97068       };
97069     }
97070   }
97071   jresult = result;
97072   return jresult;
97073 }
97074
97075
97076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97077   int jresult ;
97078   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97079   Dali::Pixel::Format result;
97080
97081   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97082   {
97083     try {
97084       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97085     } catch (std::out_of_range& e) {
97086       {
97087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97088       };
97089     } catch (std::exception& e) {
97090       {
97091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97092       };
97093     } catch (...) {
97094       {
97095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97096       };
97097     }
97098   }
97099   jresult = (int)result;
97100   return jresult;
97101 }
97102
97103
97104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97105   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97106   Dali::Devel::PixelBuffer arg2 ;
97107   float arg3 ;
97108   bool arg4 ;
97109   Dali::Devel::PixelBuffer *argp2 ;
97110
97111   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97112   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97113   if (!argp2) {
97114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97115     return ;
97116   }
97117   arg2 = *argp2;
97118   arg3 = (float)jarg3;
97119   arg4 = jarg4 ? true : false;
97120   {
97121     try {
97122       (arg1)->ApplyMask(arg2,arg3,arg4);
97123     } catch (std::out_of_range& e) {
97124       {
97125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97126       };
97127     } catch (std::exception& e) {
97128       {
97129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97130       };
97131     } catch (...) {
97132       {
97133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97134       };
97135     }
97136   }
97137 }
97138
97139
97140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97141   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97142   Dali::Devel::PixelBuffer arg2 ;
97143   float arg3 ;
97144   Dali::Devel::PixelBuffer *argp2 ;
97145
97146   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97147   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97148   if (!argp2) {
97149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97150     return ;
97151   }
97152   arg2 = *argp2;
97153   arg3 = (float)jarg3;
97154   {
97155     try {
97156       (arg1)->ApplyMask(arg2,arg3);
97157     } catch (std::out_of_range& e) {
97158       {
97159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97160       };
97161     } catch (std::exception& e) {
97162       {
97163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97164       };
97165     } catch (...) {
97166       {
97167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97168       };
97169     }
97170   }
97171 }
97172
97173
97174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97175   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97176   Dali::Devel::PixelBuffer arg2 ;
97177   Dali::Devel::PixelBuffer *argp2 ;
97178
97179   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97180   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97181   if (!argp2) {
97182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97183     return ;
97184   }
97185   arg2 = *argp2;
97186   {
97187     try {
97188       (arg1)->ApplyMask(arg2);
97189     } catch (std::out_of_range& e) {
97190       {
97191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97192       };
97193     } catch (std::exception& e) {
97194       {
97195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97196       };
97197     } catch (...) {
97198       {
97199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97200       };
97201     }
97202   }
97203 }
97204
97205
97206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97207   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97208   float arg2 ;
97209
97210   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97211   arg2 = (float)jarg2;
97212   {
97213     try {
97214       (arg1)->ApplyGaussianBlur(arg2);
97215     } catch (std::out_of_range& e) {
97216       {
97217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97218       };
97219     } catch (std::exception& e) {
97220       {
97221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97222       };
97223     } catch (...) {
97224       {
97225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97226       };
97227     }
97228   }
97229 }
97230
97231
97232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97233   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97234   uint16_t arg2 ;
97235   uint16_t arg3 ;
97236   uint16_t arg4 ;
97237   uint16_t arg5 ;
97238
97239   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97240   arg2 = (uint16_t)jarg2;
97241   arg3 = (uint16_t)jarg3;
97242   arg4 = (uint16_t)jarg4;
97243   arg5 = (uint16_t)jarg5;
97244   {
97245     try {
97246       (arg1)->Crop(arg2,arg3,arg4,arg5);
97247     } catch (std::out_of_range& e) {
97248       {
97249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97250       };
97251     } catch (std::exception& e) {
97252       {
97253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97254       };
97255     } catch (...) {
97256       {
97257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97258       };
97259     }
97260   }
97261 }
97262
97263
97264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97265   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97266   uint16_t arg2 ;
97267   uint16_t arg3 ;
97268
97269   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97270   arg2 = (uint16_t)jarg2;
97271   arg3 = (uint16_t)jarg3;
97272   {
97273     try {
97274       (arg1)->Resize(arg2,arg3);
97275     } catch (std::out_of_range& e) {
97276       {
97277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97278       };
97279     } catch (std::exception& e) {
97280       {
97281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97282       };
97283     } catch (...) {
97284       {
97285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97286       };
97287     }
97288   }
97289 }
97290
97291 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97292   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97293   Dali::Degree * arg2 ;
97294
97295   bool result = false;
97296
97297   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97298   arg2 = (Dali::Degree *)jarg2;
97299   {
97300     try {
97301       result = (arg1)->Rotate(*arg2);
97302     } catch (std::out_of_range& e) {
97303       {
97304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97305       };
97306     } catch (std::exception& e) {
97307       {
97308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97309       };
97310     } catch (...) {
97311       {
97312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97313       };
97314     }
97315   }
97316   return result;
97317 }
97318
97319
97320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97321   void * jresult ;
97322   std::string *arg1 = 0 ;
97323   Dali::ImageDimensions arg2 ;
97324   Dali::FittingMode::Type arg3 ;
97325   Dali::SamplingMode::Type arg4 ;
97326   bool arg5 ;
97327   Dali::ImageDimensions *argp2 ;
97328   Dali::Devel::PixelBuffer result;
97329
97330   if (!jarg1) {
97331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97332     return 0;
97333   }
97334   std::string arg1_str(jarg1);
97335   arg1 = &arg1_str;
97336   argp2 = (Dali::ImageDimensions *)jarg2;
97337   if (!argp2) {
97338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97339     return 0;
97340   }
97341   arg2 = *argp2;
97342   arg3 = (Dali::FittingMode::Type)jarg3;
97343   arg4 = (Dali::SamplingMode::Type)jarg4;
97344   arg5 = jarg5 ? true : false;
97345   {
97346     try {
97347       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97348     } catch (std::out_of_range& e) {
97349       {
97350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97351       };
97352     } catch (std::exception& e) {
97353       {
97354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97355       };
97356     } catch (...) {
97357       {
97358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97359       };
97360     }
97361   }
97362   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97363
97364   return jresult;
97365 }
97366
97367
97368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97369   void * jresult ;
97370   std::string *arg1 = 0 ;
97371   Dali::ImageDimensions arg2 ;
97372   Dali::FittingMode::Type arg3 ;
97373   Dali::SamplingMode::Type arg4 ;
97374   Dali::ImageDimensions *argp2 ;
97375   Dali::Devel::PixelBuffer result;
97376
97377   if (!jarg1) {
97378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97379     return 0;
97380   }
97381   std::string arg1_str(jarg1);
97382   arg1 = &arg1_str;
97383   argp2 = (Dali::ImageDimensions *)jarg2;
97384   if (!argp2) {
97385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97386     return 0;
97387   }
97388   arg2 = *argp2;
97389   arg3 = (Dali::FittingMode::Type)jarg3;
97390   arg4 = (Dali::SamplingMode::Type)jarg4;
97391   {
97392     try {
97393       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97394     } catch (std::out_of_range& e) {
97395       {
97396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97397       };
97398     } catch (std::exception& e) {
97399       {
97400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97401       };
97402     } catch (...) {
97403       {
97404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97405       };
97406     }
97407   }
97408   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97409
97410   return jresult;
97411 }
97412
97413
97414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97415   void * jresult ;
97416   std::string *arg1 = 0 ;
97417   Dali::ImageDimensions arg2 ;
97418   Dali::FittingMode::Type arg3 ;
97419   Dali::ImageDimensions *argp2 ;
97420   Dali::Devel::PixelBuffer result;
97421
97422   if (!jarg1) {
97423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97424     return 0;
97425   }
97426   std::string arg1_str(jarg1);
97427   arg1 = &arg1_str;
97428   argp2 = (Dali::ImageDimensions *)jarg2;
97429   if (!argp2) {
97430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97431     return 0;
97432   }
97433   arg2 = *argp2;
97434   arg3 = (Dali::FittingMode::Type)jarg3;
97435   {
97436     try {
97437       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97438     } catch (std::out_of_range& e) {
97439       {
97440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97441       };
97442     } catch (std::exception& e) {
97443       {
97444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97445       };
97446     } catch (...) {
97447       {
97448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97449       };
97450     }
97451   }
97452   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97453
97454   return jresult;
97455 }
97456
97457
97458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97459   void * jresult ;
97460   std::string *arg1 = 0 ;
97461   Dali::ImageDimensions arg2 ;
97462   Dali::ImageDimensions *argp2 ;
97463   Dali::Devel::PixelBuffer result;
97464
97465   if (!jarg1) {
97466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97467     return 0;
97468   }
97469   std::string arg1_str(jarg1);
97470   arg1 = &arg1_str;
97471   argp2 = (Dali::ImageDimensions *)jarg2;
97472   if (!argp2) {
97473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97474     return 0;
97475   }
97476   arg2 = *argp2;
97477   {
97478     try {
97479       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97480     } catch (std::out_of_range& e) {
97481       {
97482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97483       };
97484     } catch (std::exception& e) {
97485       {
97486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97487       };
97488     } catch (...) {
97489       {
97490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97491       };
97492     }
97493   }
97494   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97495
97496   return jresult;
97497 }
97498
97499
97500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97501   void * jresult ;
97502   std::string *arg1 = 0 ;
97503   Dali::Devel::PixelBuffer result;
97504
97505   if (!jarg1) {
97506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97507     return 0;
97508   }
97509   std::string arg1_str(jarg1);
97510   arg1 = &arg1_str;
97511   {
97512     try {
97513       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97514     } catch (std::out_of_range& e) {
97515       {
97516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97517       };
97518     } catch (std::exception& e) {
97519       {
97520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97521       };
97522     } catch (...) {
97523       {
97524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97525       };
97526     }
97527   }
97528   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97529
97530   return jresult;
97531 }
97532
97533
97534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97535   void * jresult ;
97536   std::string *arg1 = 0 ;
97537   Dali::ImageDimensions arg2 ;
97538   Dali::FittingMode::Type arg3 ;
97539   Dali::SamplingMode::Type arg4 ;
97540   bool arg5 ;
97541   Dali::ImageDimensions *argp2 ;
97542   Dali::ImageDimensions result;
97543
97544   if (!jarg1) {
97545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97546     return 0;
97547   }
97548   std::string arg1_str(jarg1);
97549   arg1 = &arg1_str;
97550   argp2 = (Dali::ImageDimensions *)jarg2;
97551   if (!argp2) {
97552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97553     return 0;
97554   }
97555   arg2 = *argp2;
97556   arg3 = (Dali::FittingMode::Type)jarg3;
97557   arg4 = (Dali::SamplingMode::Type)jarg4;
97558   arg5 = jarg5 ? true : false;
97559   {
97560     try {
97561       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97562     } catch (std::out_of_range& e) {
97563       {
97564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97565       };
97566     } catch (std::exception& e) {
97567       {
97568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97569       };
97570     } catch (...) {
97571       {
97572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97573       };
97574     }
97575   }
97576   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97577
97578   return jresult;
97579 }
97580
97581
97582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97583   void * jresult ;
97584   std::string *arg1 = 0 ;
97585   Dali::ImageDimensions arg2 ;
97586   Dali::FittingMode::Type arg3 ;
97587   Dali::SamplingMode::Type arg4 ;
97588   Dali::ImageDimensions *argp2 ;
97589   Dali::ImageDimensions result;
97590
97591   if (!jarg1) {
97592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97593     return 0;
97594   }
97595   std::string arg1_str(jarg1);
97596   arg1 = &arg1_str;
97597   argp2 = (Dali::ImageDimensions *)jarg2;
97598   if (!argp2) {
97599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97600     return 0;
97601   }
97602   arg2 = *argp2;
97603   arg3 = (Dali::FittingMode::Type)jarg3;
97604   arg4 = (Dali::SamplingMode::Type)jarg4;
97605   {
97606     try {
97607       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97608     } catch (std::out_of_range& e) {
97609       {
97610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97611       };
97612     } catch (std::exception& e) {
97613       {
97614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97615       };
97616     } catch (...) {
97617       {
97618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97619       };
97620     }
97621   }
97622   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97623
97624   return jresult;
97625 }
97626
97627
97628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97629   void * jresult ;
97630   std::string *arg1 = 0 ;
97631   Dali::ImageDimensions arg2 ;
97632   Dali::FittingMode::Type arg3 ;
97633   Dali::ImageDimensions *argp2 ;
97634   Dali::ImageDimensions result;
97635
97636   if (!jarg1) {
97637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97638     return 0;
97639   }
97640   std::string arg1_str(jarg1);
97641   arg1 = &arg1_str;
97642   argp2 = (Dali::ImageDimensions *)jarg2;
97643   if (!argp2) {
97644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97645     return 0;
97646   }
97647   arg2 = *argp2;
97648   arg3 = (Dali::FittingMode::Type)jarg3;
97649   {
97650     try {
97651       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97652     } catch (std::out_of_range& e) {
97653       {
97654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97655       };
97656     } catch (std::exception& e) {
97657       {
97658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97659       };
97660     } catch (...) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97663       };
97664     }
97665   }
97666   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97667
97668   return jresult;
97669 }
97670
97671
97672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97673   void * jresult ;
97674   std::string *arg1 = 0 ;
97675   Dali::ImageDimensions arg2 ;
97676   Dali::ImageDimensions *argp2 ;
97677   Dali::ImageDimensions result;
97678
97679   if (!jarg1) {
97680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97681     return 0;
97682   }
97683   std::string arg1_str(jarg1);
97684   arg1 = &arg1_str;
97685   argp2 = (Dali::ImageDimensions *)jarg2;
97686   if (!argp2) {
97687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97688     return 0;
97689   }
97690   arg2 = *argp2;
97691   {
97692     try {
97693       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97694     } catch (std::out_of_range& e) {
97695       {
97696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97697       };
97698     } catch (std::exception& e) {
97699       {
97700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97701       };
97702     } catch (...) {
97703       {
97704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97705       };
97706     }
97707   }
97708   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97709
97710   return jresult;
97711 }
97712
97713
97714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97715   void * jresult ;
97716   std::string *arg1 = 0 ;
97717   Dali::ImageDimensions result;
97718
97719   if (!jarg1) {
97720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97721     return 0;
97722   }
97723   std::string arg1_str(jarg1);
97724   arg1 = &arg1_str;
97725   {
97726     try {
97727       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97728     } catch (std::out_of_range& e) {
97729       {
97730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97731       };
97732     } catch (std::exception& e) {
97733       {
97734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97735       };
97736     } catch (...) {
97737       {
97738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97739       };
97740     }
97741   }
97742   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97743
97744   return jresult;
97745 }
97746
97747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97748   void * jresult ;
97749   std::string *arg1 = 0 ;
97750   Dali::ImageDimensions result;
97751
97752   if (!jarg1) {
97753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97754     return 0;
97755   }
97756   std::string arg1_str(jarg1);
97757   arg1 = &arg1_str;
97758   {
97759     try {
97760       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97761     } catch (std::out_of_range& e) {
97762       {
97763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97764       };
97765     } catch (std::exception& e) {
97766       {
97767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97768       };
97769     } catch (...) {
97770       {
97771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97772       };
97773     }
97774   }
97775   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97776
97777   return jresult;
97778 }
97779
97780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97781   void * jresult ;
97782   std::string *arg1 = 0 ;
97783   Dali::ImageDimensions arg2 ;
97784   Dali::FittingMode::Type arg3 ;
97785   Dali::SamplingMode::Type arg4 ;
97786   bool arg5 ;
97787   Dali::ImageDimensions *argp2 ;
97788   Dali::Devel::PixelBuffer result;
97789
97790   if (!jarg1) {
97791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97792     return 0;
97793   }
97794   std::string arg1_str(jarg1);
97795   arg1 = &arg1_str;
97796   argp2 = (Dali::ImageDimensions *)jarg2;
97797   if (!argp2) {
97798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97799     return 0;
97800   }
97801   arg2 = *argp2;
97802   arg3 = (Dali::FittingMode::Type)jarg3;
97803   arg4 = (Dali::SamplingMode::Type)jarg4;
97804   arg5 = jarg5 ? true : false;
97805   {
97806     try {
97807       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97808     } catch (std::out_of_range& e) {
97809       {
97810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97811       };
97812     } catch (std::exception& e) {
97813       {
97814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97815       };
97816     } catch (...) {
97817       {
97818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97819       };
97820     }
97821   }
97822   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97823
97824   return jresult;
97825 }
97826
97827
97828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97829   void * jresult ;
97830   std::string *arg1 = 0 ;
97831   Dali::ImageDimensions arg2 ;
97832   Dali::FittingMode::Type arg3 ;
97833   Dali::SamplingMode::Type arg4 ;
97834   Dali::ImageDimensions *argp2 ;
97835   Dali::Devel::PixelBuffer result;
97836
97837   if (!jarg1) {
97838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97839     return 0;
97840   }
97841   std::string arg1_str(jarg1);
97842   arg1 = &arg1_str;
97843   argp2 = (Dali::ImageDimensions *)jarg2;
97844   if (!argp2) {
97845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97846     return 0;
97847   }
97848   arg2 = *argp2;
97849   arg3 = (Dali::FittingMode::Type)jarg3;
97850   arg4 = (Dali::SamplingMode::Type)jarg4;
97851   {
97852     try {
97853       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97854     } catch (std::out_of_range& e) {
97855       {
97856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97857       };
97858     } catch (std::exception& e) {
97859       {
97860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97861       };
97862     } catch (...) {
97863       {
97864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97865       };
97866     }
97867   }
97868   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97869
97870   return jresult;
97871 }
97872
97873
97874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97875   void * jresult ;
97876   std::string *arg1 = 0 ;
97877   Dali::ImageDimensions arg2 ;
97878   Dali::FittingMode::Type arg3 ;
97879   Dali::ImageDimensions *argp2 ;
97880   Dali::Devel::PixelBuffer result;
97881
97882   if (!jarg1) {
97883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97884     return 0;
97885   }
97886   std::string arg1_str(jarg1);
97887   arg1 = &arg1_str;
97888   argp2 = (Dali::ImageDimensions *)jarg2;
97889   if (!argp2) {
97890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97891     return 0;
97892   }
97893   arg2 = *argp2;
97894   arg3 = (Dali::FittingMode::Type)jarg3;
97895   {
97896     try {
97897       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97898     } catch (std::out_of_range& e) {
97899       {
97900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97901       };
97902     } catch (std::exception& e) {
97903       {
97904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97905       };
97906     } catch (...) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97909       };
97910     }
97911   }
97912   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97913
97914   return jresult;
97915 }
97916
97917
97918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97919   void * jresult ;
97920   std::string *arg1 = 0 ;
97921   Dali::ImageDimensions arg2 ;
97922   Dali::ImageDimensions *argp2 ;
97923   Dali::Devel::PixelBuffer result;
97924
97925   if (!jarg1) {
97926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97927     return 0;
97928   }
97929   std::string arg1_str(jarg1);
97930   arg1 = &arg1_str;
97931   argp2 = (Dali::ImageDimensions *)jarg2;
97932   if (!argp2) {
97933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97934     return 0;
97935   }
97936   arg2 = *argp2;
97937   {
97938     try {
97939       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97940     } catch (std::out_of_range& e) {
97941       {
97942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97943       };
97944     } catch (std::exception& e) {
97945       {
97946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97947       };
97948     } catch (...) {
97949       {
97950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97951       };
97952     }
97953   }
97954   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97955
97956   return jresult;
97957 }
97958
97959
97960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97961   void * jresult ;
97962   std::string *arg1 = 0 ;
97963   Dali::Devel::PixelBuffer result;
97964
97965   if (!jarg1) {
97966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97967     return 0;
97968   }
97969   std::string arg1_str(jarg1);
97970   arg1 = &arg1_str;
97971   {
97972     try {
97973       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97974     } catch (std::out_of_range& e) {
97975       {
97976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97977       };
97978     } catch (std::exception& e) {
97979       {
97980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97981       };
97982     } catch (...) {
97983       {
97984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97985       };
97986     }
97987   }
97988   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97989
97990   return jresult;
97991 }
97992
97993
97994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97995   void * jresult ;
97996   Dali::Toolkit::WebView result;
97997
97998   {
97999     try {
98000       result = Dali::Toolkit::WebView::New();
98001     } catch (std::out_of_range& e) {
98002       {
98003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98004       };
98005     } catch (std::exception& e) {
98006       {
98007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98008       };
98009     } catch (Dali::DaliException e) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98012       };
98013     } catch (...) {
98014       {
98015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98016       };
98017     }
98018   }
98019   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98020   return jresult;
98021 }
98022
98023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98024   void * jresult ;
98025   Dali::Toolkit::WebView result;
98026
98027   std::string *arg1;
98028   std::string *arg2;
98029
98030   if (!jarg1) {
98031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98032     return 0;
98033   }
98034   if (!jarg2) {
98035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98036     return 0;
98037   }
98038
98039   std::string jarg1_str = std::string(jarg1);
98040   std::string jarg2_str = std::string(jarg2);
98041
98042   arg1 = &jarg1_str;
98043   arg2 = &jarg2_str;
98044
98045   {
98046     try {
98047       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98048     } catch (std::out_of_range& e) {
98049       {
98050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98051       };
98052     } catch (std::exception& e) {
98053       {
98054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98055       };
98056     } catch (Dali::DaliException e) {
98057       {
98058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98059       };
98060     } catch (...) {
98061       {
98062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98063       };
98064     }
98065   }
98066   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98067   return jresult;
98068 }
98069
98070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98071   void * jresult ;
98072   Dali::Toolkit::WebView *arg1 = 0 ;
98073   Dali::Toolkit::WebView *result = 0 ;
98074
98075   arg1 = (Dali::Toolkit::WebView *)jarg1;
98076   if (!arg1) {
98077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98078     return 0;
98079   }
98080   {
98081     try {
98082       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98083     } catch (std::out_of_range& e) {
98084       {
98085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98086       };
98087     } catch (std::exception& e) {
98088       {
98089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98090       };
98091     } catch (Dali::DaliException e) {
98092       {
98093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98094       };
98095     } catch (...) {
98096       {
98097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98098       };
98099     }
98100   }
98101   jresult = (void *)result;
98102   return jresult;
98103 }
98104
98105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98106   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98107   arg1 = (Dali::Toolkit::WebView *)jarg1;
98108   {
98109     try {
98110       delete arg1;
98111     } catch (std::out_of_range& e) {
98112       {
98113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98114       };
98115     } catch (std::exception& e) {
98116       {
98117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98118       };
98119     } catch (Dali::DaliException e) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98122       };
98123     } catch (...) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98126       };
98127     }
98128   }
98129 }
98130
98131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98132   void * jresult ;
98133   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98134   Dali::Toolkit::WebView *arg2 = 0 ;
98135   Dali::Toolkit::WebView *result = 0 ;
98136
98137   arg1 = (Dali::Toolkit::WebView *)jarg1;
98138   arg2 = (Dali::Toolkit::WebView *)jarg2;
98139   if (!arg2) {
98140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98141     return 0;
98142   }
98143   {
98144     try {
98145       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98146     } catch (std::out_of_range& e) {
98147       {
98148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98149       };
98150     } catch (std::exception& e) {
98151       {
98152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98153       };
98154     } catch (Dali::DaliException e) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98157       };
98158     } catch (...) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98161       };
98162     }
98163   }
98164   jresult = (void *)result;
98165   return jresult;
98166 }
98167
98168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98169   void * jresult ;
98170   Dali::BaseHandle arg1 ;
98171   Dali::BaseHandle *argp1 ;
98172   Dali::Toolkit::WebView result;
98173
98174   argp1 = (Dali::BaseHandle *)jarg1;
98175   if (!argp1) {
98176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98177     return 0;
98178   }
98179   arg1 = *argp1;
98180   {
98181     try {
98182       result = Dali::Toolkit::WebView::DownCast(arg1);
98183     } catch (std::out_of_range& e) {
98184       {
98185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98186       };
98187     } catch (std::exception& e) {
98188       {
98189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98190       };
98191     } catch (Dali::DaliException e) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98194       };
98195     } catch (...) {
98196       {
98197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98198       };
98199     }
98200   }
98201   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98202   return jresult;
98203 }
98204
98205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98206   return (int) Dali::Toolkit::WebView::Property::URL;
98207 }
98208
98209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98210   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98211 }
98212
98213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98214   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98215 }
98216
98217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98218   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98219 }
98220
98221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98222   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98223 }
98224
98225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98226   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98227 }
98228
98229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98230   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98231 }
98232
98233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98234   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98235 }
98236
98237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98238   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98239   std::string *arg2;
98240
98241   arg1 = (Dali::Toolkit::WebView *)jarg1;
98242
98243   if (!jarg2) {
98244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98245     return;
98246   }
98247
98248   std::string jarg2str = std::string(jarg2);
98249   arg2 = &jarg2str;
98250   {
98251     try {
98252       (arg1)->LoadUrl((std::string const &)*arg2);
98253     } catch (std::out_of_range& e) {
98254       {
98255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98256       };
98257     } catch (std::exception& e) {
98258       {
98259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98260       };
98261     } catch (Dali::DaliException e) {
98262       {
98263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98264       };
98265     } catch (...) {
98266       {
98267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98268       };
98269     }
98270   }
98271 }
98272
98273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98274   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98275   std::string *arg2;
98276
98277   arg1 = (Dali::Toolkit::WebView *)jarg1;
98278   if (!jarg2) {
98279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98280     return;
98281   }
98282   std::string jarg2str = std::string(jarg2);
98283   arg2 = &jarg2str;
98284   {
98285     try {
98286       (arg1)->LoadHTMLString((std::string const &)*arg2);
98287     } catch (std::out_of_range& e) {
98288       {
98289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98290       };
98291     } catch (std::exception& e) {
98292       {
98293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98294       };
98295     } catch (Dali::DaliException e) {
98296       {
98297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98298       };
98299     } catch (...) {
98300       {
98301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98302       };
98303     }
98304   }
98305 }
98306
98307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98308   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98309
98310   arg1 = (Dali::Toolkit::WebView *)jarg1;
98311   {
98312     try {
98313       (arg1)->Reload();
98314     } catch (std::out_of_range& e) {
98315       {
98316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98317       };
98318     } catch (std::exception& e) {
98319       {
98320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98321       };
98322     } catch (Dali::DaliException e) {
98323       {
98324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98325       };
98326     } catch (...) {
98327       {
98328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98329       };
98330     }
98331   }
98332 }
98333
98334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98335   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98336
98337   arg1 = (Dali::Toolkit::WebView *)jarg1;
98338   {
98339     try {
98340       (arg1)->StopLoading();
98341     } catch (std::out_of_range& e) {
98342       {
98343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98344       };
98345     } catch (std::exception& e) {
98346       {
98347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98348       };
98349     } catch (Dali::DaliException e) {
98350       {
98351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98352       };
98353     } catch (...) {
98354       {
98355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98356       };
98357     }
98358   }
98359 }
98360
98361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98362   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98363
98364   arg1 = (Dali::Toolkit::WebView *)jarg1;
98365   {
98366     try {
98367       (arg1)->Suspend();
98368     } catch (std::out_of_range& e) {
98369       {
98370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98371       };
98372     } catch (std::exception& e) {
98373       {
98374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98375       };
98376     } catch (Dali::DaliException e) {
98377       {
98378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98379       };
98380     } catch (...) {
98381       {
98382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98383       };
98384     }
98385   }
98386 }
98387
98388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98389   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98390
98391   arg1 = (Dali::Toolkit::WebView *)jarg1;
98392   {
98393     try {
98394       (arg1)->Resume();
98395     } catch (std::out_of_range& e) {
98396       {
98397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98398       };
98399     } catch (std::exception& e) {
98400       {
98401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98402       };
98403     } catch (Dali::DaliException e) {
98404       {
98405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98406       };
98407     } catch (...) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98410       };
98411     }
98412   }
98413 }
98414
98415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98416   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98417
98418   arg1 = (Dali::Toolkit::WebView *)jarg1;
98419   {
98420     try {
98421       (arg1)->GoBack();
98422     } catch (std::out_of_range& e) {
98423       {
98424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98425       };
98426     } catch (std::exception& e) {
98427       {
98428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98429       };
98430     } catch (Dali::DaliException e) {
98431       {
98432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98433       };
98434     } catch (...) {
98435       {
98436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98437       };
98438     }
98439   }
98440 }
98441
98442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98443   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98444
98445   arg1 = (Dali::Toolkit::WebView *)jarg1;
98446   {
98447     try {
98448       (arg1)->GoForward();
98449     } catch (std::out_of_range& e) {
98450       {
98451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98452       };
98453     } catch (std::exception& e) {
98454       {
98455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98456       };
98457     } catch (Dali::DaliException e) {
98458       {
98459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98460       };
98461     } catch (...) {
98462       {
98463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98464       };
98465     }
98466   }
98467 }
98468
98469 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98470   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98471   bool ret;
98472
98473   arg1 = (Dali::Toolkit::WebView *)jarg1;
98474   {
98475     try {
98476       ret = (arg1)->CanGoBack();
98477     } catch (std::out_of_range& e) {
98478       {
98479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98480       };
98481     } catch (std::exception& e) {
98482       {
98483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98484       };
98485     } catch (Dali::DaliException e) {
98486       {
98487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98488       };
98489     } catch (...) {
98490       {
98491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98492       };
98493     }
98494   }
98495   return ret;
98496 }
98497
98498 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98499   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98500   bool ret;
98501
98502   arg1 = (Dali::Toolkit::WebView *)jarg1;
98503   {
98504     try {
98505       ret = (arg1)->CanGoForward();
98506     } catch (std::out_of_range& e) {
98507       {
98508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98509       };
98510     } catch (std::exception& e) {
98511       {
98512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98513       };
98514     } catch (Dali::DaliException e) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98517       };
98518     } catch (...) {
98519       {
98520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98521       };
98522     }
98523   }
98524   return ret;
98525 }
98526
98527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98528   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98529   std::string *arg2;
98530
98531   arg1 = (Dali::Toolkit::WebView *)jarg1;
98532   if (!jarg2) {
98533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98534     return;
98535   }
98536   std::string jarg2_str = std::string(jarg2);
98537   arg2 = &jarg2_str;
98538
98539   {
98540     try {
98541       if (jarg3) {
98542         void (*handler)(char*) = (void (*)(char*)) jarg3;
98543         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98544           handler(SWIG_csharp_string_callback(result.c_str()));
98545         });
98546       } else {
98547         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98548       }
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98564       };
98565     }
98566   }
98567 }
98568
98569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98570 {
98571   if (!jarg2) {
98572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98573     return;
98574   }
98575
98576   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98577   std::string exposedObjectName = jarg2;
98578   void (*handler)(char*) = (void (*)(char*)) jarg3;
98579
98580   {
98581     try {
98582       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98583         handler(SWIG_csharp_string_callback(message.c_str()));
98584       });
98585     } catch (std::out_of_range& e) {
98586       {
98587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98588       };
98589     } catch (std::exception& e) {
98590       {
98591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98592       };
98593     } catch (Dali::DaliException e) {
98594       {
98595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98596       };
98597     } catch (...) {
98598       {
98599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98600       };
98601     }
98602   }
98603 }
98604
98605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98606   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98607
98608   arg1 = (Dali::Toolkit::WebView *)jarg1;
98609   {
98610     try {
98611       (arg1)->ClearHistory();
98612     } catch (std::out_of_range& e) {
98613       {
98614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98615       };
98616     } catch (std::exception& e) {
98617       {
98618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98619       };
98620     } catch (Dali::DaliException e) {
98621       {
98622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98623       };
98624     } catch (...) {
98625       {
98626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98627       };
98628     }
98629   }
98630 }
98631
98632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98633   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98634
98635   arg1 = (Dali::Toolkit::WebView *)jarg1;
98636   {
98637     try {
98638       (arg1)->ClearCache();
98639     } catch (std::out_of_range& e) {
98640       {
98641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98642       };
98643     } catch (std::exception& e) {
98644       {
98645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98646       };
98647     } catch (Dali::DaliException e) {
98648       {
98649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98650       };
98651     } catch (...) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98654       };
98655     }
98656   }
98657 }
98658
98659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98660   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98661
98662   arg1 = (Dali::Toolkit::WebView *)jarg1;
98663   {
98664     try {
98665       (arg1)->ClearCookies();
98666     } catch (std::out_of_range& e) {
98667       {
98668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98669       };
98670     } catch (std::exception& e) {
98671       {
98672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98673       };
98674     } catch (Dali::DaliException e) {
98675       {
98676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98677       };
98678     } catch (...) {
98679       {
98680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98681       };
98682     }
98683   }
98684 }
98685
98686 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98687     return (Dali::Toolkit::Control *)jarg1;
98688 }
98689
98690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98691   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98692   SignalConverter::WebViewPageLoadSignal* result = NULL;
98693   {
98694     try {
98695       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98696     } catch (std::out_of_range& e) {
98697       {
98698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98699       };
98700     } catch (std::exception& e) {
98701       {
98702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98703       };
98704     } catch (Dali::DaliException e) {
98705       {
98706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98707       };
98708     } catch (...) {
98709       {
98710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98711       };
98712     }
98713   }
98714   return (void*) result;
98715 }
98716
98717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98718   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98719   SignalConverter::WebViewPageLoadSignal* result = NULL;
98720   {
98721     try {
98722       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98723     } catch (std::out_of_range& e) {
98724       {
98725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98726       };
98727     } catch (std::exception& e) {
98728       {
98729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98730       };
98731     } catch (Dali::DaliException e) {
98732       {
98733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98734       };
98735     } catch (...) {
98736       {
98737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98738       };
98739     }
98740   }
98741   return (void*) result;
98742 }
98743
98744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98745 {
98746   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98747   {
98748     try {
98749       delete object;
98750     } catch (std::out_of_range& e) {
98751       {
98752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98753       };
98754     } catch (std::exception& e) {
98755       {
98756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98757       };
98758     } catch (Dali::DaliException e) {
98759       {
98760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98761       };
98762     } catch (...) {
98763       {
98764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98765       };
98766     }
98767   }
98768 }
98769
98770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98771 {
98772   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98773   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98774   {
98775     try {
98776       proxy->Connect(callback);
98777     } catch (std::out_of_range& e) {
98778       {
98779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98780       };
98781     } catch (std::exception& e) {
98782       {
98783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98784       };
98785     } catch (Dali::DaliException e) {
98786       {
98787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98788       };
98789     } catch (...) {
98790       {
98791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98792       };
98793     }
98794   }
98795 }
98796
98797
98798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98799   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98800   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98801   {
98802     try {
98803       proxy->Disconnect(callback);
98804     } catch (std::out_of_range& e) {
98805       {
98806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98807       };
98808     } catch (std::exception& e) {
98809       {
98810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98811       };
98812     } catch (Dali::DaliException e) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98815       };
98816     } catch (...) {
98817       {
98818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98819       };
98820     }
98821   }
98822 }
98823
98824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98825   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98826   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98827   {
98828     try {
98829       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98830     } catch (std::out_of_range& e) {
98831       {
98832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98833       };
98834     } catch (std::exception& e) {
98835       {
98836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98837       };
98838     } catch (Dali::DaliException e) {
98839       {
98840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98841       };
98842     } catch (...) {
98843       {
98844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98845       };
98846     }
98847   }
98848   return (void*) result;
98849 }
98850
98851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98852 {
98853   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98854   {
98855     try {
98856       delete object;
98857     } catch (std::out_of_range& e) {
98858       {
98859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98860       };
98861     } catch (std::exception& e) {
98862       {
98863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98864       };
98865     } catch (Dali::DaliException e) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98868       };
98869     } catch (...) {
98870       {
98871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98872       };
98873     }
98874   }
98875 }
98876
98877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98878 {
98879   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98880   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98881   {
98882     try {
98883       proxy->Connect(callback);
98884     } catch (std::out_of_range& e) {
98885       {
98886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98887       };
98888     } catch (std::exception& e) {
98889       {
98890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98891       };
98892     } catch (Dali::DaliException e) {
98893       {
98894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98895       };
98896     } catch (...) {
98897       {
98898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98899       };
98900     }
98901   }
98902 }
98903
98904
98905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98906   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98907   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98908   {
98909     try {
98910       proxy->Disconnect(callback);
98911     } catch (std::out_of_range& e) {
98912       {
98913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98914       };
98915     } catch (std::exception& e) {
98916       {
98917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98918       };
98919     } catch (Dali::DaliException e) {
98920       {
98921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98922       };
98923     } catch (...) {
98924       {
98925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98926       };
98927     }
98928   }
98929 }
98930
98931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98932   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98933   char * jresult = SWIG_csharp_string_callback((const char *)result);
98934   return jresult;
98935 }
98936
98937 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98938   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98939   return result;
98940 }
98941
98942
98943 struct NativeImageSourcePtrHandle
98944 {
98945   NativeImageSourcePtr Ptr;
98946 };
98947
98948 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98949 {
98950   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98951   return (NativeImageInterface*)(arg1);
98952 }
98953
98954 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98955 {
98956   void* jresult;
98957   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98958   {
98959     try {
98960       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98961     }
98962     catch (std::out_of_range & e) {
98963       {
98964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98965       };
98966     }
98967     catch (std::exception & e) {
98968       {
98969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98970       };
98971     }
98972     catch (Dali::DaliException e) {
98973       {
98974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98975       };
98976     }
98977     catch (...) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98980       };
98981     }
98982   }
98983   jresult = (void *)handle;
98984   return jresult;
98985 }
98986
98987 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98988 {
98989   void* jresult;
98990   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98991   jresult = (void*)( handle->Ptr.Get() );
98992   return jresult;
98993 }
98994
98995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98996   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98997   {
98998     try {
98999       delete arg1;
99000     }
99001     catch (std::out_of_range & e) {
99002       {
99003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99004       };
99005     }
99006     catch (std::exception & e) {
99007       {
99008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99009       };
99010     }
99011     catch (Dali::DaliException e) {
99012       {
99013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99014       };
99015     }
99016     catch (...) {
99017       {
99018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99019       };
99020     }
99021   }
99022 }
99023
99024 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99025 {
99026   void* jresult;
99027   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99028   uint16_t* arg2 = (uint16_t*)(jarg2);
99029   uint16_t* arg3 = (uint16_t*)(jarg3);
99030   uint16_t* arg4 = (uint16_t*)(jarg4);
99031   {
99032     try {
99033       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99034     }
99035     catch (std::out_of_range & e) {
99036       {
99037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99038       };
99039     }
99040     catch (std::exception & e) {
99041       {
99042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99043       };
99044     }
99045     catch (Dali::DaliException e) {
99046       {
99047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99048       };
99049     }
99050     catch (...) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99053       };
99054     }
99055   }
99056   return jresult;
99057 }
99058
99059 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99060 {
99061   bool jresult;
99062   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99063
99064   {
99065     try {
99066       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99067     }
99068     catch (std::out_of_range & e) {
99069       {
99070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99071       };
99072     }
99073     catch (std::exception & e) {
99074       {
99075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99076       };
99077     }
99078     catch (Dali::DaliException e) {
99079       {
99080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99081       };
99082     }
99083     catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99086       };
99087     }
99088   }
99089   return jresult;
99090 }
99091
99092
99093 #ifdef __cplusplus
99094 }
99095 #endif